anchor.diff:                      (dwff (demorgan wff))
                       (operator (if (wff-p dwff) (wff-operator dwff)))
                       (operand (if (wff-p dwff) (wff-wffs dwff))))
  +  "Remove nested predicates of the same type and flatten a wff."
     (if (or (fact-p dwff) (every #'fact-p operand))
       dwff
       (cond ((equal operator 'not)
  
positive.code:                            &aux (cnf (cnf-rule facts implications)))))
    facts implications cnf)
  
  (defstruct
    (wff
      (:constructor defwff (operator wffs)))
    operator wffs)
  
  (defun cnf-rule (facts-wff implications-wff)
    (cnf-wff (defwff 'or (list (cnf-wff (defwff 'not (list facts-wff)))
                               (cnf-wff implications-wff)))))
  
  (defun cnf-wff (wff)
    (let ((dwff (flatten (demorgan wff))))
      (cond
        ((fact-p dwff) dwff)
  
negative.code: (defun demorgan (wff &aux
                       (operator (if (wff-p wff) (wff-operator wff)))
                       (operand (if (wff-p wff) (wff-wffs wff))))
    "Transform a wff using DeMorgan's laws."
    (if (fact-p wff)
      wff
      (cond ((and (equal operator 'not)
  