anchor.diff:          }
       fun (th : Protected<thm0>) ->
           choice {
  +        let! pth = pth
           let! th = th
           let tm = concl th
           // CLEAN : Rename these values to something sensible.
           let! foo1 = rator tm
           let! foo2 = rand foo1
  -        let! foo3 = pth
  -        let! foo4 = INST [tm, P] (Choice.result foo3)
  -        return! MP (Choice.result foo4) (Choice.result th)
  +        let! foo3 = INST [tm, P] (Choice.result pth)
  +        return! MP (Choice.result foo3) (Choice.result th)
           }
           |> Choice.mapError (fun e -> nestedFailure e "EQF_ELIM") : Protected<thm0>
   
  
positive.code:     let P = parse_term @"P:bool"
      let pth =
          choice {
          // CLEAN : Rename these values to something sensible.
          let! foo1 = AP_THM NOT_DEF P
          let! foo2 = CONV_RULE (RAND_CONV BETA_CONV) (Choice.result foo1)
          return! SYM (Choice.result foo2)
          }
      fun (th : Protected<thm0>) ->
          choice {
          let! foo3 = pth
          let! th = th
          let tm = concl th
          // CLEAN : Rename these values to something sensible.
          let! foo1 = rator tm
          let! foo2 = rand foo1
          let! foo4 = INST [tm, P] (Choice.result foo3)
          return! EQ_MP (Choice.result foo4) (Choice.result th)
          }
          |> Choice.mapError (fun e -> nestedFailure e "NOT_INTRO") : Protected<thm0>
  
negative.code:     if List.isEmpty tms then
          return th
      else
          let! avs =
              let avs =
                  let tm = concl th
                  fst <| chop_list (length tms) (fst <| strip_forall tm)
              Choice.List.map (Choice.map snd << dest_var) avs
          let! tms' = Choice.List.map type_of tms
          let! tyins = Choice.List.fold2 (fun acc x y -> type_match x y acc) [] avs tms'
  
          let! foo1 = INST_TYPE tyins (Choice.result th)
          return! SPECL tms (Choice.result foo1)
  