anchor.diff:          | MissingIterator view ->
               fmt "constraint '{0}' should have an iterator, but does not"
                   [ printDView view ]
  -        | SymInIteratedConstraint sym ->
  -            fmt "symbol '{0}' not allowed in an iterated constraint"
  -                [ printSymbolicSentence sym ]
           | Traversal err -> printTraversalError printError err
           |> error
  
positive.code: 
          mapMessages Traversal (mapper (mkTypedSub normalRec defn))
  
      /// <summary>
      ///     Runs a downclosure check using Z3.
      /// </summary>
      /// <param name="check">The check to run.</param>
      /// <returns>
      ///     True if <paramref name="check"/> succeeds (is a tautology);
      ///     false if not; an error if <paramref name="check"/> contains
      ///     symbols or otherwise cannot be decided by Z3.
      /// </returns>
      let runDownclosureCheck (check : BoolExpr<Sym<Var>>) : Result<bool, Error> =
          // Expression equivalence cannot handle symbols, so try remove them.
          // TODO(CaptainHayashi): is it sound to approximate here?
          let removeResult =
              mapTraversal
                  (removeSymFromBoolExpr SymInIteratedConstraint)
                  (mkTypedSub normalRec check)
          // If check is a tautology, it will be equivalent to 'true'.
          lift
              (equiv BTrue >> equivHolds id)
              (mapMessages Traversal removeResult)
  
      /// <summary>
      ///     Checks the base downclosure property.
  
negative.code:                The definition of emp can only mention global variables, so it
                 need not need to be freshened. *)
              let checkR = lift (mkImplies ed) baseDefnR
              let baseHoldsR = lift runDownclosureCheck checkR
              bind
                  (fun baseHolds ->
                      match baseHolds with
                      | Proven -> ok deferred
                      | Refuted -> fail (BaseDownclosureError ([func], defn, ed))
                      | Inconclusive reason ->
                          ok (NeedsBaseDownclosure (func, reason)::deferred))
                  baseHoldsR
  
      /// <summary>
  