anchor.diff:      let rec find_conditional fvs tm = 
           match tm with
           | Comb(s, t) -> 
  -            if is_cond tm && intersect (frees(Choice.get <| lhand s)) fvs = []
  -            then tm
  +            if is_cond tm && intersect (frees(Choice.get <| lhand s)) fvs = [] then tm
               else 
                   (try 
                        (find_conditional fvs s)
  
positive.code: 
  /// Convert a term to negation normal form.
  let NNF_CONV = 
      (GEN_NNF_CONV false (ALL_CONV, fun t -> REFL t, REFL(Choice.get <| mk_neg t)) : conv)
  
  /// Convert a term to negation normal form.
  let NNFC_CONV = 
      (GEN_NNF_CONV true (ALL_CONV, fun t -> REFL t, REFL(Choice.get <| mk_neg t)) : conv)
  
  (* ------------------------------------------------------------------------- *)
  (* Skolemize a term already in NNF (doesn't matter if it's not prenex).      *)
  
negative.code: 
  /// Right-associates a term with respect to an associative binary operator.
  let ASSOC_CONV th = 
      let v =
          choice {
              let th' = SYM(SPEC_ALL th)
              let! tm1 = Choice.bind (rhs << concl) th'
              let! opx, yopz = dest_comb tm1
              let! op, x = dest_comb opx
              let! y = lhand yopz
              let! z = rand yopz
              return (th', op, x, y, z)
          }
      let rec distrib tm = 
          choice {
              let! (th', op, x, y, z) = v
              match tm with
              | Comb(Comb(op', Comb(Comb(op'', p), q)), r) when op' = op && op'' = op -> 
                  let th1 =  INST [p, x; q, y; r, z] th'
                  let! tm1 = Choice.bind (rand << concl) th1
                  let! l, r' = dest_comb tm1
                  let th2 = AP_TERM l (distrib r')
                  let! tm2 = Choice.bind (rand << concl) th
                  let th3 = distrib tm2
                  return! TRANS th1 (TRANS th2 th3)
              | _ -> 
                  return! REFL tm
          }
      let rec assoc tm = 
          choice {
              let! (_, op, _, _, _) = v
              match tm with
              | Comb(Comb(op', p) as l, q) when op' = op -> 
                  let th = AP_TERM l (assoc q)
                  let! tm1 = Choice.bind (rand << concl) th
                  return! TRANS th (distrib tm1)
              | _ -> 
                  return! REFL tm
          }
      assoc
  
  (* ------------------------------------------------------------------------- *)
  