anchor.diff:               SEMIRING_POW_CONV) (<)
       INT_POLY_CONV
   
  -make_overloadable "divides" (parse_type ":A->A->bool")
  -make_overloadable "mod" (parse_type ":A->A->A->bool")
  -make_overloadable "coprime" (parse_type ":A#A->bool")
  -make_overloadable "gcd" (parse_type ":A#A->A")
  -parse_as_infix("==", (10, "right"))
  +//make_overloadable "divides" (parse_type ":A->A->bool")
  +//make_overloadable "mod" (parse_type ":A->A->A->bool")
  +//make_overloadable "coprime" (parse_type ":A#A->bool")
  +//make_overloadable "gcd" (parse_type ":A#A->A")
  +//parse_as_infix("==", (10, "right"))
   
   (* ------------------------------------------------------------------------- *)
   (* Instantiate the ring and ideal procedures.                                *)
  
positive.code:     |> THEN <| CONV_TAC(ONCE_DEPTH_CONV INT_POLYEQ_CONV)
      |> THEN <| EXISTS_POLY_TAC
  
  let INTEGER_RULE tm = prove(tm, INTEGER_TAC)
  
  (* ------------------------------------------------------------------------- *)
  (* Existence of integer gcd, and the Bezout identity.                        *)
  
negative.code:         (parse_term "real_mod n (x:real) y = ?q. integer q /\ x - y = q * n")
  
  overload_interface("mod", (parse_term "real_mod"))
  
  (* ------------------------------------------------------------------------- *)
  (* Integer divisibility.                                                     *)
  (* ------------------------------------------------------------------------- *)
  parse_as_infix("divides", (12, "right"))
  overload_interface("divides", (parse_term "int_divides:int->int->bool"))
  
  let int_divides = new_definition(parse_term "a divides b <=> ?x. b = a * x")
  
  (* ------------------------------------------------------------------------- *)
  (* Integer congruences.                                                      *)
  (* ------------------------------------------------------------------------- *)
  
  parse_as_prefix "mod"
  overload_interface("mod", (parse_term "int_mod:int->int->int->bool"))
  
  let int_mod = new_definition(parse_term "(mod n) x y = n divides (x - y)")
  
  let int_congruent = 
  