anchor.diff:          ((parse_term @"!n. 1 EXP n = 1"), 
            INDUCT_TAC
            |> THEN <| ASM_REWRITE_TAC [EXP; MULT_CLAUSES])
  +
   let EXP_1 = 
       prove
           ((parse_term @"!n. n EXP 1 = n"), 
            REWRITE_TAC [ONE; EXP; MULT_CLAUSES; ADD_CLAUSES])
  +
   let EXP_2 = 
       prove
           ((parse_term @"!n. n EXP 2 = n * n"), 
            REWRITE_TAC 
                [BIT0_THM; BIT1_THM; EXP; EXP_ADD; MULT_CLAUSES; ADD_CLAUSES])
  +
   let MULT_EXP = 
       prove
           ((parse_term @"!p m n. (m * n) EXP p = m EXP p * n EXP p"), 
  
positive.code:         ((parse_term @"!m. m * 0 = 0"), 
           INDUCT_TAC
           |> THEN <| ASM_REWRITE_TAC [MULT; ADD_CLAUSES])
  let MULT_SUC = 
      prove
          ((parse_term @"!m n. m * (SUC n) = m + (m * n)"), 
           INDUCT_TAC
           |> THEN <| ASM_REWRITE_TAC [MULT; ADD_CLAUSES; ADD_ASSOC])
  let MULT_CLAUSES = 
      prove
          ((parse_term @"(!n. 0 * n = 0) /\
  
negative.code:          |> THEN <| MATCH_ACCEPT_TAC SUB_ADD_LCANCEL)
  
  let LEFT_SUB_DISTRIB = 
      prove((parse_term @"!m n p. m * (n - p) = m * n - m * p"), 
            REPEAT GEN_TAC
            |> THEN <| CONV_TAC SYM_CONV
            |> THEN <| DISJ_CASES_TAC(SPECL [(parse_term @"n:num");
                                             (parse_term @"p:num")] LE_CASES)
            |> THENL <| [FIRST_ASSUM(fun th -> REWRITE_TAC [REWRITE_RULE [GSYM SUB_EQ_0] th])
                         |> THEN <| ASM_REWRITE_TAC [MULT_CLAUSES; SUB_EQ_0; LE_MULT_LCANCEL];
                         POP_ASSUM(CHOOSE_THEN SUBST1_TAC << REWRITE_RULE [LE_EXISTS])
                         |> THEN <| REWRITE_TAC [LEFT_ADD_DISTRIB]
                         |> THEN <| REWRITE_TAC [ONCE_REWRITE_RULE [ADD_SYM] ADD_SUB]])
  
  let RIGHT_SUB_DISTRIB = 
      prove
          ((parse_term @"!m n p. (m - n) * p = m * p - n * p"), 
           ONCE_REWRITE_TAC [MULT_SYM]
           |> THEN <| MATCH_ACCEPT_TAC LEFT_SUB_DISTRIB)
  
  let SUC_SUB1 = 
      prove((parse_term @"!n. SUC n - 1 = n"), REWRITE_TAC [ONE; SUB_SUC; SUB_0])
  
  let EVEN_SUB = 
      prove((parse_term @"!m n. EVEN(m - n) <=> m <= n \/ (EVEN(m) <=> EVEN(n))"), 
            REPEAT GEN_TAC
            |> THEN <| ASM_CASES_TAC(parse_term @"m <= n:num")
            |> THENL <| [ASM_MESON_TAC [SUB_EQ_0; EVEN];
                         ALL_TAC]
            |> THEN <| DISJ_CASES_TAC(SPECL [(parse_term @"m:num");
                                             (parse_term @"n:num")] LE_CASES)
            |> THEN <| ASM_SIMP_TAC []
            |> THEN <| FIRST_ASSUM(MP_TAC << AP_TERM(parse_term @"EVEN") << MATCH_MP SUB_ADD)
            |> THEN <| ASM_MESON_TAC [EVEN_ADD])
  
  let ODD_SUB = 
      prove
  