anchor.diff:      let tm' = list_mk_disj(setify(disjuncts tm))
       DISJ_ACI_RULE(mk_eq(tm, tm'))
   
  -///(* ------------------------------------------------------------------------- *)
  -///(* General NNF conversion. The user supplies some conversion to be applied   *)
  -///(* to atomic formulas.                                                       *)
  -///(*                                                                           *)
  -///(* "Iff"s are split conjunctively or disjunctively according to the flag     *)
  -///(* argument (conjuctively = true) until a universal quantifier (modulo       *)
  -///(* current parity) is passed; after that they are split conjunctively. This  *)
  -///(* is appropriate when the result is passed to a disjunctive splitter        *)
  -///(* followed by a clausal form inner core, such as MESON.                     *)
  -///(*                                                                           *)
  -///(* To avoid some duplicate computation, this function will in general        *)
  -///(* enter a recursion where it simultaneously computes NNF representations    *)
  -///(* for "p" and "~p", so the user needs to supply an atomic "conversion"      *)
  -///(* that does the same.                                                       *)
  -///(* ------------------------------------------------------------------------- *)
  +(* ------------------------------------------------------------------------- *)
  +(* General NNF conversion. The user supplies some conversion to be applied   *)
  +(* to atomic formulas.                                                       *)
  +(*                                                                           *)
  +(* "Iff"s are split conjunctively or disjunctively according to the flag     *)
  +(* argument (conjuctively = true) until a universal quantifier (modulo       *)
  +(* current parity) is passed; after that they are split conjunctively. This  *)
  +(* is appropriate when the result is passed to a disjunctive splitter        *)
  +(* followed by a clausal form inner core, such as MESON.                     *)
  +(*                                                                           *)
  +(* To avoid some duplicate computation, this function will in general        *)
  +(* enter a recursion where it simultaneously computes NNF representations    *)
  +(* for "p" and "~p", so the user needs to supply an atomic "conversion"      *)
  +(* that does the same.                                                       *)
  +(* ------------------------------------------------------------------------- *)
   let (GEN_NNF_CONV : bool -> conv * (term -> thm * thm) -> conv) = 
       let and_tm = (parse_term "(/\)")
       let or_tm = (parse_term "(\/)")
  
positive.code:         TRANS th (strengthen(rand(concl th)))
      weakcnf, strongcnf
  
  ///(* ------------------------------------------------------------------------- *)
  ///(* Simply right-associate w.r.t. a binary operator.                          *)
  ///(* ------------------------------------------------------------------------- *)
  let ASSOC_CONV th = 
      let th' = SYM(SPEC_ALL th)
      let opx, yopz = dest_comb(rhs(concl th'))
  
negative.code:          LEFT_OR_EXISTS_THM; RIGHT_OR_EXISTS_THM; LEFT_AND_EXISTS_THM; 
           RIGHT_AND_EXISTS_THM]
  
  (* ------------------------------------------------------------------------- *)
  (* Weak and normal DNF conversion. The "weak" form gives a disjunction of    *)
  (* conjunctions, but has no particular associativity at either level and     *)
  (* may contain duplicates. The regular forms give canonical right-associate  *)
  (* lists without duplicates, but do not remove subsumed disjuncts.           *)
  (*                                                                           *)
  (* In both cases the input term is supposed to be in NNF already. We do go   *)
  (* inside quantifiers and transform their body, but don't move them.         *)
  (* ------------------------------------------------------------------------- *)
  let WEAK_DNF_CONV, DNF_CONV = 
      let pth1 = TAUT(parse_term "a /\ (b \/ c) <=> a /\ b \/ a /\ c")
      let pth2 = TAUT(parse_term "(a \/ b) /\ c <=> a /\ c \/ b /\ c")
  