anchor.diff:  
       /// Introduces an assumption.
       let ASSUME tm = 
  -        if compare (Choice.get <| type_of tm) bool_ty = 0 then Choice.succeed <| Sequent([tm], tm)
  -        else Choice.failwith "ASSUME: not a proposition"
  +        type_of tm 
  +        |> Choice.bind (fun ty ->
  +            if compare ty bool_ty = 0 then Choice.succeed <| Sequent([tm], tm)
  +            else Choice.failwith "ASSUME: not a proposition")
       
       /// Equality version of the Modus Ponens rule.
       let EQ_MP thm1 thm2 =
  
positive.code:             let th = Choice.succeed <| Sequent([], tm)
              the_axioms := th :: (!the_axioms)
              th
          else Choice2Of2 <| Exception "new_axiom: Not a proposition"
      
      (* ------------------------------------------------------------------------- *)
      (* Handling of (term) definitions.                                           *)
  
negative.code: 
      /// Instantiates types in a theorem.
      let INST_TYPE theta thm =
          // TODO: revise this
          let INST_TYPE theta (Sequent(asl, c)) = 
              try
                  let inst_fn = Choice.get << inst theta
                  Choice.succeed <| Sequent(term_image inst_fn asl, inst_fn c)
              with Failure s ->
                  Choice.failwith s
          Choice.bind (INST_TYPE theta) thm
      
      /// Instantiates free variables in a theorem.
      let INST theta thm =
          // TODO: revise this
          let INST theta (Sequent(asl, c)) = 
              try
                  let inst_fun = Choice.get << vsubst theta
                  Choice.succeed <| Sequent(term_image inst_fun asl, inst_fun c)
              with Failure s ->
                  Choice.failwith s
          Choice.bind (INST theta) thm
      
      (* ------------------------------------------------------------------------- *)
  