anchor.diff:              match l with
               | Success (_, gl, _ as gs) :: _ ->
                   print_goalstate 1 gs
  -            | Error _ :: _ -> Format.print_string "Erroneous goalstate"
  +            | Error _ :: _ -> Format.print_string "Erroneous goalstack"
               | [] -> Format.print_string "Empty goalstack"
           | _ -> 
               match l with
  
positive.code: 
  /// Produces a case split based on a disjunctive theorem.
  let (DISJ_CASES_TAC : thm_tactic) = 
      fun dth g -> 
          let f = 
              let fun1 l i =
                  match l with
                  | [th1; th2] -> DISJ_CASES (INSTANTIATE_ALL i dth) th1 th2
                  | _ -> Choice.failwith "DISJ_CASES_TAC.fun1: Unhandled case."
              let dtm = concl <| Choice.get dth
              let l, r = Choice.get <| dest_disj dtm
              let thl = ASSUME l
              let thr = ASSUME r
              fun (asl, w) -> 
                  (null_meta, [("", thl) :: asl, w; ("", thr) :: asl, w], fun i tl -> fun1 tl i)
                  |> Choice.result
          f g |> Choice.mapError (fun e -> nestedFailure e "DISJ_CASES_TAC: Failure.")
  
  /// Solves any goal from contradictory theorem.
  let (CONTR_TAC : thm_tactic) = 
  
negative.code:         | [] -> INSTANTIATE_ALL i th
          | _ -> Choice.failwith "CONTR_TAC.propagate_thm: Unhandled case."
      fun cth (asl, w) -> 
          choice { 
              let th = CONTR w cth
              return (null_meta, [], propagate_thm th)
          }
          |> Choice.mapError (fun e -> nestedFailure e "CONTR_TAC: Failure.")
  
  /// Solves a goal which is an instance of the supplied theorem.
  let (MATCH_ACCEPT_TAC : thm_tactic) =
  