anchor.diff:                  let formals, c = SS.open_comp formals c in
                   let tres_comp = get_result_comp c in
                   let binders, body = eta_expand [] formals e (U.comp_result tres_comp) in
  -                (binders, body, formals, tres_comp), false
  +                (binders, body, subst_comp formals binders tres_comp), false
                 | Tm_refine (bv, _) -> aux' bv.sort
  -              | _ -> ([], e, [], S.mk_Total t_norm), false
  +              | _ -> ([], e, S.mk_Total t_norm), false
               in
               aux' t_norm
             end
  
positive.code:         let valid = mkApp("Valid", [l_not_a]) in
          let not_valid_a = mkNot <| mkApp("Valid", [a]) in
          [Util.mkAssume(mkForall (Env.get_range env) ([[l_not_a]], [aa], mkIff(not_valid_a, valid)), Some "not interpretation", "l_not-interp")] in
      // let mk_forall_interp : env -> string -> term -> decls_t = fun env for_all tt ->
      //     let aa = ("a", Term_sort) in
      //     let bb = ("b", Term_sort) in
      //     let xx = ("x", Term_sort) in
      //     let a = mkFreeV aa in
      //     let b = mkFreeV bb in
      //     let x = mkFreeV xx in
      //     let l_forall_a_b = mkApp(for_all, [a;b]) in
      //     let valid = mkApp("Valid", [l_forall_a_b]) in
      //     let valid_b_x = mkApp("Valid", [mk_ApplyTT b x]) in
      //     [Util.mkAssume(mkForall (Env.get_range env) ([[l_forall_a_b]], [aa;bb], mkIff(mkForall([[mk_HasTypeZ x a]], [xx], mkImp(mk_HasTypeZ x a, valid_b_x)), valid)),
      //                  Some "forall interpretation",
      //                  "forall-interp")] in
      // let mk_exists_interp : env -> string -> term -> decls_t = fun env for_some tt ->
      //     let aa = ("a", Term_sort) in
      //     let bb = ("b", Term_sort) in
      //     let xx = ("x", Term_sort) in
      //     let a = mkFreeV aa in
      //     let b = mkFreeV bb in
      //     let x = mkFreeV xx in
      //     let l_exists_a_b = mkApp(for_some, [a;b]) in
      //     let valid = mkApp("Valid", [l_exists_a_b]) in
      //     let valid_b_x = mkApp("Valid", [mk_ApplyTT b x]) in
      //     [Util.mkAssume(mkForall (Env.get_range env) ([[l_exists_a_b]], [aa;bb], mkIff(mkExists([[mk_HasTypeZ x a]], [xx], mkImp(mk_HasTypeZ x a, valid_b_x)), valid)),
      //                  Some "exists interpretation",
      //                  "exists-interp")] in
     let mk_range_interp : env -> string -> term -> decls_t = fun env range tt ->
          let range_ty = mkApp(range, []) in
          [Util.mkAssume(mk_HasTypeZ (mk_Range_const ()) range_ty, Some "Range_const typing", (varops.mk_unique "typing_range_const"))] in
  
negative.code: 
              let vars, guards, env', binder_decls, _ = encode_binders None binders env' in
              let guard, guard_decls =
                  match pre_opt with
                  | None -> mk_and_l guards, []
                  | Some pre ->
  