anchor.diff:  
           let headZ = translateVFunc ctx funcDecls head
   
  -        (* Don't emit a rule if it entails true: not only is such a rule
  -           trivial, but MuZ3 will complain about interpreted heads. *)
  -        if headZ.IsTrue
  -        then None
  -        else
  -            let core = ctx.MkImplies (bodyZ, headZ)
  -
  -            (* If this rule involves one or more variables, we must universally
  -               quantify over them.
  -               MuZ3 will complain if we universally quantify over nothing,
  -               though, so we need to be careful! *)
  -
  -            Some (if Array.isEmpty vars
  -                  then core
  -                  else ctx.MkForall (vars, core) :> Z3.BoolExpr)
  +        mkQuantifiedEntailment ctx vars bodyZ headZ
  +
  +
  +    (*
  +     * Variables
  +     *)
   
       /// <summary>
       ///     Constructs a rule for initialising a variable.
  
positive.code:         >> (fun a -> ctx.MkAnd a)
  
      (*
       * Variables
       *)
  
      /// <summary>
      ///     Constructs a rule implying view, whose body is a conjunction of
      ///     a <c>BoolExpr</c> and a <c>GView</c>.
      /// </summary>
      /// <param name="ctx">
      ///     The Z3 context to use to model the func.
      /// </param>
      /// <param name="funcDecls">
      ///     The map of <c>FuncDecls</c> to use in the modelling.
  
negative.code:             (fun (view, def) ->
                   // TODO(CaptainHayashi): de-duplicate this with mkRule.
                   let vars =
                       seq {
                           yield! (varsInBool def)
                           for param in view.Params do
                               yield! (varsIn param)
                       }
                       |> Set.ofSeq
                       |> Set.map (fun (name, ty) ->
                                       ctx.MkConst (constToString name,
                                                    Translator.typeToSort ctx ty))
                       |> Set.toArray
  
                   // Introduce 'V ^ ¬D(V) -> unsafe'.
                   Translator.mkQuantifiedEntailment
                       ctx
                       vars
                       (ctx.MkAnd [| def |> mkNot |> boolToZ3 ctx
                                     Translator.translateVFunc ctx fm view |])
                       unsafeapp
                   |> Option.iter (fixedpoint.AddRule))
              ds
  
          Map.iter (fun (s : string) g -> fixedpoint.AddRule (g, ctx.MkSymbol s :> Z3.Symbol)) rs
  