anchor.diff:          let a = mkFreeV aa in
           let b = mkFreeV bb in
           let x = mkFreeV xx in
  -        let valid = mkApp("Valid", [mkApp(for_some, [a;b])]) 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
  -        [Term.Assume(mkForall([[valid]], [aa;bb], mkIff(mkExists([[mk_HasTypeZ x a]], [xx], mkImp(mk_HasTypeZ x a, valid_b_x)), valid)),
  +        [Term.Assume(mkForall([[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 ->
  
positive.code:         let b = mkFreeV bb in
          let x = mkFreeV xx in
          let y = mkFreeV yy in
          let valid = mkApp("Valid", [mkApp(eq3, [a;b;x;y])]) in
          [Term.Assume(mkForall([[valid]], [aa;bb;xx;yy], mkIff(mkEq(x, y), valid)), Some "Eq3 interpretation", "eq3-interp")] in
      let mk_imp_interp : env -> string -> term -> decls_t = fun env imp tt ->
          let aa = ("a", Term_sort) in
          let bb = ("b", Term_sort) in
          let a = mkFreeV aa in
          let b = mkFreeV bb in
          let valid = mkApp("Valid", [mkApp(imp, [a;b])]) in
          let valid_a = mkApp("Valid", [a]) in
          let valid_b = mkApp("Valid", [b]) in
          [Term.Assume(mkForall([[valid]], [aa;bb], mkIff(mkImp(valid_a, valid_b), valid)), Some "==> interpretation", "l_imp-interp")] in
      let mk_iff_interp : env -> string -> term -> decls_t = fun env iff tt ->
          let aa = ("a", Term_sort) in
          let bb = ("b", Term_sort) in
          let a = mkFreeV aa in
          let b = mkFreeV bb in
          let valid = mkApp("Valid", [mkApp(iff, [a;b])]) in
          let valid_a = mkApp("Valid", [a]) in
          let valid_b = mkApp("Valid", [b]) in
          [Term.Assume(mkForall([[valid]], [aa;bb], mkIff(mkIff(valid_a, valid_b), valid)), Some "<==> interpretation", "l_iff-interp")] in
      let mk_not_interp : env -> string -> term -> decls_t = fun env l_not tt ->
          let aa = ("a", Term_sort) in
          let a = mkFreeV aa in
          let valid = mkApp("Valid", [mkApp(l_not, [a])]) in
          let not_valid_a = mkNot <| mkApp("Valid", [a]) in
          [Term.Assume(mkForall([[valid]], [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
  
negative.code:         let a = mkFreeV aa in
          let x = mkFreeV xx in
          let y = mkFreeV yy in
          let eq2_x_y = mkApp(eq2, [a;x;y]) in
          let valid = mkApp("Valid", [eq2_x_y]) in
          [Term.Assume(mkForall([[eq2_x_y]], [aa;xx;yy], mkIff(mkEq(x, y), valid)), Some "Eq2 interpretation", "eq2-interp")] in
      let mk_eq3_interp : env -> string -> term -> decls_t = fun env eq3 tt ->
          let aa = ("a", Term_sort) in
          let bb = ("b", Term_sort) in
  