[
  Type   integers                     Alias ints
  Type   integers-from                Alias from
  Type   integers-up-to               Alias up-to
  Type   bounded-integers             Alias bounded-ints
  Type   positive-integers            Alias pos-ints
  Type   negative-integers            Alias neg-ints
  Type   natural-numbers              Alias nats
  Funcon natural-successor            Alias nat-succ
  Funcon natural-predecessor          Alias nat-pred
  Funcon integer-add                  Alias int-add
  Funcon integer-subtract             Alias int-sub
  Funcon integer-multiply             Alias int-mul
  Funcon integer-divide               Alias int-div
  Funcon integer-modulo               Alias int-mod
  Funcon integer-power                Alias int-pow
  Funcon integer-absolute-value       Alias int-abs
  Funcon integer-negate               Alias int-neg
  Funcon integer-is-less              Alias is-less
  Funcon integer-is-less-or-equal     Alias is-less-or-equal
  Funcon integer-is-greater           Alias is-greater
  Funcon integer-is-greater-or-equal  Alias is-greater-or-equal
  Funcon binary-natural               Alias binary
  Funcon octal-natural                Alias octal
  Funcon decimal-natural              Alias decimal
  Funcon hexadecimal-natural          Alias hexadecimal
  Funcon integer-sequence
]

Built-in Type
  integers
Alias
  ints = integers

Built-in Type
  integers-from(_:integers) <: integers
Alias
  from = integers-from

Built-in Type
  integers-up-to(_:integers) <: integers
Alias
  up-to = integers-up-to

Type
  bounded-integers(M:integers, N:integers)
    ~> integers-from(M) & integers-up-to(N)
Alias
  bounded-ints = bounded-integers

Type
  positive-integers ~> integers-from(1)
Alias
  pos-ints = positive-integers

Type
  negative-integers ~> integers-up-to(-1)
Alias
  neg-ints = negative-integers

Type
  natural-numbers ~> integers-from(0)
Alias
  nats = natural-numbers

Built-in Funcon
  natural-successor(N:natural-numbers) : =>natural-numbers
Alias
  nat-succ = natural-successor

Built-in Funcon
  natural-predecessor(_:natural-numbers) : =>natural-numbers?
Alias
  nat-pred = natural-predecessor

Assert
  natural-predecessor(0) == ( )

Built-in Funcon
  integer-add(_:integers*) : =>integers
Alias
  int-add = integer-add

Built-in Funcon
  integer-subtract(_:integers, _:integers) : =>integers
Alias
  int-sub = integer-subtract

Built-in Funcon
  integer-multiply(_:integers*) : =>integers
Alias
  int-mul = integer-multiply

Built-in Funcon
  integer-divide(_:integers, _:integers) : =>integers?
Alias
  int-div = integer-divide

Assert
  integer-divide(_:integers, 0) == ( )

Built-in Funcon
  integer-modulo(_:integers, _:integers) : =>integers?
Alias
  int-mod = integer-modulo

Assert
  integer-modulo(_:integers, 0) == ( )

Built-in Funcon
  integer-power(_:integers, _:natural-numbers) : =>integers
Alias
  int-pow = integer-power

Built-in Funcon
  integer-absolute-value(_:integers) : =>natural-numbers
Alias
  int-abs = integer-absolute-value

Funcon
  integer-negate(N:integers) : =>integers
    ~> integer-subtract(0, N)
Alias
  int-neg = integer-negate

Built-in Funcon
  integer-is-less(_:integers, _:integers) : =>booleans
Alias
  is-less = integer-is-less

Built-in Funcon
  integer-is-less-or-equal(_:integers, _:integers) : =>booleans
Alias
  is-less-or-equal = integer-is-less-or-equal

Built-in Funcon
  integer-is-greater(_:integers, _:integers) : =>booleans
Alias
  is-greater = integer-is-greater

Built-in Funcon
  integer-is-greater-or-equal(_:integers, _:integers) : =>booleans
Alias
  is-greater-or-equal = integer-is-greater-or-equal

Built-in Funcon
  binary-natural(_:strings) : =>natural-numbers?
Alias
  binary = binary-natural

Built-in Funcon
  octal-natural(_:strings) : =>natural-numbers?
Alias
  octal = octal-natural

Built-in Funcon
  decimal-natural(_:strings) : =>natural-numbers?
Alias
  decimal = decimal-natural

Built-in Funcon
  hexadecimal-natural(_:strings) : =>natural-numbers?
Alias
  hexadecimal = hexadecimal-natural

Funcon
  integer-sequence(_:integers, _:integers) : =>integers*

Rule
  is-greater(M, N) == false
  ------------------------------------------------
  integer-sequence(M:integers, N:integers)
    ~> (M, integer-sequence(integer-add(M, 1), N))
Rule
  is-greater(M, N) == true
  -----------------------------------------------
  integer-sequence(M:integers, N:integers) ~> ( )