anchor.diff:          pars.Add("engine", ctx.MkSymbol("pdr"))
           fixedpoint.Parameters <- pars
   
  -        List.iter
  -            (fun (view, def) ->
  -                 match (Translator.mkRule reals id ctx fm def Multiset.empty view) with
  -                 | Some rule -> fixedpoint.AddRule rule
  -                 | None -> ())
  -            ds
  -
           let unsafe = ctx.MkFuncDecl ("unsafe", [||], ctx.MkBoolSort () :> Z3.Sort)
           fixedpoint.RegisterRelation unsafe
           let unsafeapp = unsafe.Apply [| |] :?> Z3.BoolExpr
   
  -        List.iter
  -            (fun (view, def) ->
  -                 // TODO(CaptainHayashi): de-duplicate this with mkRule.
  -                 let vars =
  -                     seq {
  -                         yield! (mapOverVars Mapper.mapBoolCtx findVars def)
  -                         for param in view.Params do
  -                             yield! (mapOverVars Mapper.mapCtx findVars param)
  -                     }
  -                     |> Set.ofSeq
  -                     |> Set.map
  -                            (fun (var : CTyped<Var>) ->
  -                                 ctx.MkConst (valueOf var,
  -                                              Translator.typeToSort reals ctx (typeOf var)))
  -                     |> Set.toArray
  -
  -                 // Introduce 'V ^ ¬D(V) -> unsafe'.
  -                 Translator.mkQuantifiedEntailment
  -                     ctx
  -                     vars
  -                     (ctx.MkAnd [| def |> mkNot |> boolToZ3 reals id ctx
  -                                   Translator.translateVFunc reals id ctx fm view |])
  -                     unsafeapp
  -                 |> Option.iter (fixedpoint.AddRule))
  -            ds
  +        List.iter (uncurry (genViewDefRule reals ctx fm fixedpoint unsafeapp)) ds
   
           Map.iter (fun (s : string) g -> fixedpoint.AddRule (g, ctx.MkSymbol s :> Z3.Symbol)) rs
           Map.iter (fun _ g -> fixedpoint.RegisterRelation g) fm
  
positive.code: module Run =
      open Starling.Core.Z3.Expr
  
      /// <summary>
      ///     Generates a MuZ3 fixedpoint.
      /// </summary>
  
negative.code:       : Result<MuModel, Error> =
          let funcDecls, definites = translateViewDefs reals ctx ds
          let vrules = translateVariables reals ctx funcDecls svars
  
          let axseq = Map.toSeq xs
          let trules = Seq.choose (translateTerm reals ctx funcDecls) axseq
  
          let tdc = translateDeferredCheck reals ctx funcDecls svars
          let drulesResult = lift (Seq.choose id) (collect (Seq.map tdc cs))
  