~/bend-docscommunity

nat.bend checks

raw source on the hub · import bend-mathlib@0.6.0.0/nat.bend as MNat

bend-mathlib/nat.bend: Nat arithmetic (add, mul, sub, min, max, pow) and order (le, lt, ge, gt).

1 import
import Base

Laws

law add_zero provedsource · line 5 · raw

@x:Nat -> {Nat.add(x, 0n) == x : Nat}

Zero is a right identity for addition: x + 0 = x.

law zero_add provedsource · line 18 · raw

@-x:Nat -> {Nat.add(0n, x) == x : Nat}

Zero is a left identity for addition: 0 + x = x.

law add_succ provedsource · line 26 · raw

@n:Nat -> @-m:Nat -> {Nat.add(n, 1n+m) == 1n+Nat.add(n, m) : Nat}

Adding a successor on the right: n + (m + 1) = (n + m) + 1.

law succ_add provedsource · line 40 · raw

@-n:Nat -> @-m:Nat -> {Nat.add(1n+n, m) == 1n+Nat.add(n, m) : Nat}

Adding a successor on the left: (n + 1) + m = (n + m) + 1.

law add_comm provedsource · line 49 · raw

@n:Nat -> @m:Nat -> {Nat.add(n, m) == Nat.add(m, n) : Nat}

Addition is commutative: n + m = m + n.

law add_assoc provedsource · line 71 · raw

@a:Nat -> @-b:Nat -> @-c:Nat -> {Nat.add(Nat.add(a, b), c) == Nat.add(a, Nat.add(b, c)) : Nat}

Addition is associative: (a + b) + c = a + (b + c).

law add_left_comm provedsource · line 86 · raw

@a:Nat -> @b:Nat -> @-c:Nat -> {Nat.add(a, Nat.add(b, c)) == Nat.add(b, Nat.add(a, c)) : Nat}

Left commutativity of addition: a + (b + c) = b + (a + c).

law add_right_comm provedsource · line 103 · raw

@a:Nat -> @b:Nat -> @c:Nat -> {Nat.add(Nat.add(a, b), c) == Nat.add(Nat.add(a, c), b) : Nat}

Right commutativity of addition: (a + b) + c = (a + c) + b.

law add_add_add_comm provedsource · line 118 · raw

@a:Nat -> @b:Nat -> @c:Nat -> @-d:Nat -> {Nat.add(Nat.add(a, b), Nat.add(c, d)) == Nat.add(Nat.add(a, c), Nat.add(b, d)) : Nat}

Four-way regrouping of a sum: (a + b) + (c + d) = (a + c) + (b + d).

law succ_inj provedsource · line 141 · raw

@-a:Nat -> @-b:Nat -> @e:{1n+a == 1n+b : Nat} -> {a == b : Nat}

The successor function is injective: a + 1 = b + 1 implies a = b.

law zero_ne_succ provedsource · line 156 · raw

@-n:Nat -> @_:{0n == 1n+n : Nat} -> Empty

Zero is not a successor.

law succ_ne_zero provedsource · line 168 · raw

@-n:Nat -> @_:{1n+n == 0n : Nat} -> Empty

A successor is not zero.

law add_left_cancel provedsource · line 176 · raw

@a:Nat -> @-b:Nat -> @-c:Nat -> @e:{Nat.add(a, b) == Nat.add(a, c) : Nat} -> {b == c : Nat}

Addition cancels on the left: a + b = a + c implies b = c.

law add_right_cancel provedsource · line 191 · raw

@a:Nat -> @b:Nat -> @c:Nat -> @e:{Nat.add(a, b) == Nat.add(c, b) : Nat} -> {a == c : Nat}

Addition cancels on the right: a + b = c + b implies a = c.

law mul_zero provedsource · line 203 · raw

@x:Nat -> {Nat.mul(x, 0n) == 0n : Nat}

Zero absorbs multiplication on the right: x * 0 = 0.

law zero_mul provedsource · line 215 · raw

@-x:Nat -> {Nat.mul(0n, x) == 0n : Nat}

Zero absorbs multiplication on the left: 0 * x = 0.

law mul_one provedsource · line 223 · raw

@x:Nat -> {Nat.mul(x, 1n) == x : Nat}

One is a right identity for multiplication: x * 1 = x.

law one_mul provedsource · line 236 · raw

@x:Nat -> {Nat.mul(1n, x) == x : Nat}

One is a left identity for multiplication: 1 * x = x.

law mul_succ provedsource · line 244 · raw

@n:Nat -> @m:Nat -> {Nat.mul(n, 1n+m) == Nat.add(Nat.mul(n, m), n) : Nat}

Multiplying by a successor on the right: n * (m + 1) = n * m + n.

law succ_mul provedsource · line 261 · raw

@n:Nat -> @m:Nat -> {Nat.mul(1n+n, m) == Nat.add(Nat.mul(n, m), m) : Nat}

Multiplying by a successor on the left: (n + 1) * m = n * m + m.

law mul_comm provedsource · line 271 · raw

@n:Nat -> @m:Nat -> {Nat.mul(n, m) == Nat.mul(m, n) : Nat}

Multiplication is commutative: n * m = m * n.

law add_mul provedsource · line 288 · raw

@a:Nat -> @-b:Nat -> @c:Nat -> {Nat.mul(Nat.add(a, b), c) == Nat.add(Nat.mul(a, c), Nat.mul(b, c)) : Nat}

Multiplication distributes over addition on the right: (a + b) * c = a * c + b * c.

law mul_add provedsource · line 305 · raw

@a:Nat -> @b:Nat -> @c:Nat -> {Nat.mul(a, Nat.add(b, c)) == Nat.add(Nat.mul(a, b), Nat.mul(a, c)) : Nat}

Multiplication distributes over addition on the left: a * (b + c) = a * b + a * c.

law mul_assoc provedsource · line 322 · raw

@a:Nat -> @b:Nat -> @c:Nat -> {Nat.mul(Nat.mul(a, b), c) == Nat.mul(a, Nat.mul(b, c)) : Nat}

Multiplication is associative: (a * b) * c = a * (b * c).

law le_refl provedsource · line 359 · raw

@a:Nat -> le(a, a)

Every natural is at most itself: a <= a.

law zero_le provedsource · line 371 · raw

@b:Nat -> le(0n, b)

Zero is at most every natural: 0 <= b.

law le_succ provedsource · line 383 · raw

@n:Nat -> le(n, 1n+n)

Every natural is at most its successor: n <= n + 1.

law le_add_right provedsource · line 395 · raw

@n:Nat -> @k:Nat -> le(n, Nat.add(n, k))

Adding on the right never decreases a natural: n <= n + k.

law le_trans provedsource · line 408 · raw

@a:Nat -> @b:Nat -> @c:Nat -> @ab:le(a, b) -> @bc:le(b, c) -> le(a, c)

The order is transitive: a <= b and b <= c imply a <= c.

law le_antisymm provedsource · line 430 · raw

@a:Nat -> @b:Nat -> @ab:le(a, b) -> @ba:le(b, a) -> {a == b : Nat}

The order is antisymmetric: a <= b and b <= a imply a = b.

law le_total provedsource · line 450 · raw

@a:Nat -> @b:Nat -> Or(le(a, b), le(b, a))

The order is total: a <= b or b <= a.

law le_total_d provedsource · line 467 · raw

@a:Nat -> @b:Nat -> Either<&2, &2, le(a, b), le(b, a)>

The order is total, as a reusable sum: a <= b or b <= a.

law lt_irrefl provedsource · line 484 · raw

@a:Nat -> @_:lt(a, a) -> Empty

No natural is less than itself.

law lt_trans provedsource · line 496 · raw

@a:Nat -> @b:Nat -> @c:Nat -> @ab:lt(a, b) -> @bc:lt(b, c) -> lt(a, c)

The strict order is transitive: a < b and b < c imply a < c.

law le_of_lt provedsource · line 520 · raw

@a:Nat -> @b:Nat -> @h:lt(a, b) -> le(a, b)

A strict inequality implies the weak one: a < b implies a <= b.

law le_of_ge provedsource · line 538 · raw

@a:Nat -> @b:Nat -> @h:ge(a, b) -> le(b, a)

Flipping a >= b gives b <= a.

law ge_of_le provedsource · line 556 · raw

@a:Nat -> @b:Nat -> @h:le(b, a) -> ge(a, b)

Flipping b <= a gives a >= b.

law lt_of_gt provedsource · line 574 · raw

@a:Nat -> @b:Nat -> @h:gt(a, b) -> lt(b, a)

Flipping a > b gives b < a.

law gt_of_lt provedsource · line 592 · raw

@a:Nat -> @b:Nat -> @h:lt(b, a) -> gt(a, b)

Flipping b < a gives a > b.

law sub_zero provedsource · line 610 · raw

@n:Nat -> {Nat.sub(n, 0n) == n : Nat}

Subtracting zero changes nothing: n - 0 = n.

law zero_sub provedsource · line 622 · raw

@n:Nat -> {Nat.sub(0n, n) == 0n : Nat}

Truncated subtraction from zero is zero: 0 - n = 0.

law sub_self provedsource · line 634 · raw

@n:Nat -> {Nat.sub(n, n) == 0n : Nat}

A natural minus itself is zero: n - n = 0.

law succ_sub_succ provedsource · line 646 · raw

@-n:Nat -> @-m:Nat -> {Nat.sub(1n+n, 1n+m) == Nat.sub(n, m) : Nat}

Subtracting successors: (n + 1) - (m + 1) = n - m.

law add_sub_cancel provedsource · line 655 · raw

@n:Nat -> @m:Nat -> {Nat.sub(Nat.add(n, m), m) == n : Nat}

Adding then subtracting m cancels: (n + m) - m = n.

law add_sub_cancel_left provedsource · line 672 · raw

@n:Nat -> @m:Nat -> {Nat.sub(Nat.add(n, m), n) == m : Nat}

Adding then subtracting n cancels: (n + m) - n = m.

law sub_add_cancel provedsource · line 685 · raw

@n:Nat -> @m:Nat -> @h:le(m, n) -> {Nat.add(Nat.sub(n, m), m) == n : Nat}

If m <= n, subtracting and adding m back gives n: (n - m) + m = n.

law sub_sub provedsource · line 706 · raw

@n:Nat -> @m:Nat -> @k:Nat -> {Nat.sub(Nat.sub(n, m), k) == Nat.sub(n, Nat.add(m, k)) : Nat}

Subtracting twice is subtracting the sum: (n - m) - k = n - (m + k).

law sub_le provedsource · line 724 · raw

@n:Nat -> @m:Nat -> le(Nat.sub(n, m), n)

Truncated subtraction never increases: n - m <= n.

law div_mod_eq provedsource · line 776 · raw

@+a:Nat -> @+b:Nat -> {Nat.add(Nat.mul(Nat.div(a, 1n+b), 1n+b), Nat.mod(a, 1n+b)) == a : Nat}

The division equation, for a positive divisor 1 + b: (a / (1 + b)) * (1 + b) + a % (1 + b) = a.

law div_eq_zero_of_le provedsource · line 813 · raw

@+a:Nat -> @+b:Nat -> @h:le(a, b) -> {Nat.div(a, 1n+b) == 0n : Nat}

A number at most b divides by 1 + b to zero: a <= b implies a / (1 + b) = 0.

law div_le_div provedsource · line 856 · raw

@+a:Nat -> @+c:Nat -> @b:Nat -> @h:le(a, c) -> le(Nat.div(a, 1n+b), Nat.div(c, 1n+b))

Division by a positive divisor is monotone: a <= c implies a / (1 + b) <= c / (1 + b).

law add_div_left provedsource · line 884 · raw

@+a:Nat -> @+b:Nat -> {Nat.div(Nat.add(1n+b, a), 1n+b) == 1n+Nat.div(a, 1n+b) : Nat}

Adding the divisor adds one to the quotient: ((1 + b) + a) / (1 + b) = 1 + a / (1 + b).

law le_div_iff_mul_le provedsource · line 941 · raw

@n:Nat -> @+a:Nat -> @+b:Nat -> {Nat.is_le(n, Nat.div(a, 1n+b)) == Nat.is_le(Nat.mul(n, 1n+b), a) : Bool}

A quotient is compared by multiplying back: n <= a / (1 + b) tests as n * (1 + b) <= a.

law min_comm provedsource · line 957 · raw

@a:Nat -> @b:Nat -> {Nat.min(a, b) == Nat.min(b, a) : Nat}

Minimum is commutative.

law max_comm provedsource · line 975 · raw

@a:Nat -> @b:Nat -> {Nat.max(a, b) == Nat.max(b, a) : Nat}

Maximum is commutative.

law min_self provedsource · line 993 · raw

@a:Nat -> {Nat.min(a, a) == a : Nat}

The minimum of a natural and itself is itself.

law max_self provedsource · line 1006 · raw

@a:Nat -> {Nat.max(a, a) == a : Nat}

The maximum of a natural and itself is itself.

law min_zero provedsource · line 1019 · raw

@a:Nat -> {Nat.min(a, 0n) == 0n : Nat}

The minimum with zero is zero: min(a, 0) = 0.

law zero_min provedsource · line 1031 · raw

@a:Nat -> {Nat.min(0n, a) == 0n : Nat}

The minimum with zero is zero: min(0, a) = 0.

law max_zero provedsource · line 1043 · raw

@a:Nat -> {Nat.max(a, 0n) == a : Nat}

Zero is an identity for maximum: max(a, 0) = a.

law zero_max provedsource · line 1055 · raw

@a:Nat -> {Nat.max(0n, a) == a : Nat}

Zero is an identity for maximum: max(0, a) = a.

law min_assoc provedsource · line 1067 · raw

@a:Nat -> @b:Nat -> @c:Nat -> {Nat.min(Nat.min(a, b), c) == Nat.min(a, Nat.min(b, c)) : Nat}

Minimum is associative.

law max_assoc provedsource · line 1086 · raw

@a:Nat -> @b:Nat -> @c:Nat -> {Nat.max(Nat.max(a, b), c) == Nat.max(a, Nat.max(b, c)) : Nat}

Maximum is associative.

law min_add_max provedsource · line 1105 · raw

@a:Nat -> @b:Nat -> {Nat.add(Nat.min(a, b), Nat.max(a, b)) == Nat.add(a, b) : Nat}

The minimum plus the maximum is the sum: min(a, b) + max(a, b) = a + b.

law min_le_left provedsource · line 1126 · raw

@a:Nat -> @b:Nat -> le(Nat.min(a, b), a)

The minimum is at most its left argument.

law min_le_right provedsource · line 1143 · raw

@a:Nat -> @b:Nat -> le(Nat.min(a, b), b)

The minimum is at most its right argument.

law le_max_left provedsource · line 1160 · raw

@a:Nat -> @b:Nat -> le(a, Nat.max(a, b))

The left argument is at most the maximum.

law le_max_right provedsource · line 1177 · raw

@a:Nat -> @b:Nat -> le(b, Nat.max(a, b))

The right argument is at most the maximum.

law pow_zero provedsource · line 1194 · raw

@-a:Nat -> {Nat.pow(a, 0n) == 1n : Nat}

Any natural to the power zero is one.

law pow_succ provedsource · line 1202 · raw

@-a:Nat -> @-n:Nat -> {Nat.pow(a, 1n+n) == Nat.mul(a, Nat.pow(a, n)) : Nat}

A power with a successor exponent: a^(n+1) = a * a^n.

law pow_one provedsource · line 1211 · raw

@a:Nat -> {Nat.pow(a, 1n) == a : Nat}

Any natural to the power one is itself.

law one_pow provedsource · line 1219 · raw

@n:Nat -> {Nat.pow(1n, n) == 1n : Nat}

One to any power is one.

law pow_add provedsource · line 1232 · raw

@a:Nat -> @m:Nat -> @n:Nat -> {Nat.pow(a, Nat.add(m, n)) == Nat.mul(Nat.pow(a, m), Nat.pow(a, n)) : Nat}

Exponents add under multiplication: a^(m+n) = a^m * a^n.

law double_eq_add provedsource · line 1252 · raw

@n:Nat -> {Nat.double(n) == Nat.add(n, n) : Nat}

Doubling is adding a natural to itself.

law is_eq_refl provedsource · line 1266 · raw

@n:Nat -> {Nat.is_eq(n, n) == True{} : Bool}

Every natural tests equal to itself.

law is_eq_comm provedsource · line 1278 · raw

@a:Nat -> @b:Nat -> {Nat.is_eq(a, b) == Nat.is_eq(b, a) : Bool}

The equality test is symmetric.

law eq_of_is_eq provedsource · line 1296 · raw

@a:Nat -> @b:Nat -> @h:{Nat.is_eq(a, b) == True{} : Bool} -> {a == b : Nat}

If the equality test says true, the naturals are equal.

law is_ge_eq_is_le provedsource · line 1315 · raw

@a:Nat -> @b:Nat -> {Nat.is_ge(a, b) == Nat.is_le(b, a) : Bool}

A >= b tests the same as b <= a.

law is_gt_eq_is_lt provedsource · line 1333 · raw

@a:Nat -> @b:Nat -> {Nat.is_gt(a, b) == Nat.is_lt(b, a) : Bool}

A > b tests the same as b < a.

law is_lt_eq_succ_le provedsource · line 1351 · raw

@a:Nat -> @b:Nat -> {Nat.is_lt(a, b) == Nat.is_le(1n+a, b) : Bool}

A < b tests the same as a + 1 <= b.

law not_is_le provedsource · line 1372 · raw

@a:Nat -> @b:Nat -> {Bool.not(Nat.is_le(a, b)) == Nat.is_lt(b, a) : Bool}

Not (a <= b) tests the same as b < a.

law not_is_lt provedsource · line 1389 · raw

@a:Nat -> @b:Nat -> {Bool.not(Nat.is_lt(a, b)) == Nat.is_le(b, a) : Bool}

Not (a < b) tests the same as b <= a.

law lt_succ_self provedsource · line 1406 · raw

@n:Nat -> lt(n, 1n+n)

Every natural is less than its successor: n < n + 1.

law succ_le_succ provedsource · line 1418 · raw

@-a:Nat -> @-b:Nat -> @h:le(a, b) -> le(1n+a, 1n+b)

The successor preserves the order: a <= b implies a + 1 <= b + 1.

law le_of_succ_le_succ provedsource · line 1428 · raw

@-a:Nat -> @-b:Nat -> @h:le(1n+a, 1n+b) -> le(a, b)

The order of successors is the order of the naturals: a + 1 <= b + 1 implies a <= b.

law lt_of_lt_of_le provedsource · line 1438 · raw

@a:Nat -> @b:Nat -> @c:Nat -> @ab:lt(a, b) -> @bc:le(b, c) -> lt(a, c)

A < b and b <= c imply a < c.

law lt_of_le_of_lt provedsource · line 1462 · raw

@a:Nat -> @b:Nat -> @c:Nat -> @ab:le(a, b) -> @bc:lt(b, c) -> lt(a, c)

A <= b and b < c imply a < c.

law add_le_add_left provedsource · line 1486 · raw

@-a:Nat -> @-b:Nat -> @k:Nat -> @h:le(a, b) -> le(Nat.add(k, a), Nat.add(k, b))

Adding on the left preserves the order: a <= b implies k + a <= k + b.

law add_le_add_right provedsource · line 1501 · raw

@+a:Nat -> @+b:Nat -> @+k:Nat -> @h:le(a, b) -> le(Nat.add(a, k), Nat.add(b, k))

Adding on the right preserves the order: a <= b implies a + k <= b + k.

law add_le_add_iff_left provedsource · line 1514 · raw

@k:Nat -> @-a:Nat -> @-b:Nat -> {Nat.is_le(a, b) == Nat.is_le(Nat.add(k, a), Nat.add(k, b)) : Bool}

Adding the same amount on the left does not change the order test: a <= b tests as k + a <= k + b.

law add_le_add provedsource · line 1528 · raw

@+a:Nat -> @+b:Nat -> @+c:Nat -> @+d:Nat -> @h1:le(a, c) -> @h2:le(b, d) -> le(Nat.add(a, b), Nat.add(c, d))

Adding two bounded summands stays bounded: a <= c and b <= d imply a + b <= c + d.

law le_and_le_sub_iff_add_le provedsource · line 1541 · raw

@a:Nat -> @-b:Nat -> @c:Nat -> {Bool.and(Nat.is_le(a, c), Nat.is_le(b, Nat.sub(c, a))) == Nat.is_le(Nat.add(a, b), c) : Bool}

A sum is at most c exactly when a <= c and b <= c - a: a + b <= c tests as both.

law le_zero_eq provedsource · line 1559 · raw

@n:Nat -> @h:le(n, 0n) -> {n == 0n : Nat}

The only natural at most zero is zero.

law lt_zero provedsource · line 1572 · raw

@n:Nat -> @_:lt(n, 0n) -> Empty

No natural is less than zero.

law not_le_of_lt provedsource · line 1584 · raw

@a:Nat -> @b:Nat -> @h:lt(a, b) -> {Nat.is_le(b, a) == False{} : Bool}

A strict inequality rules out the reverse weak one: a < b implies b <= a is false.

law not_lt_of_le provedsource · line 1602 · raw

@a:Nat -> @b:Nat -> @h:le(a, b) -> {Nat.is_lt(b, a) == False{} : Bool}

A weak inequality rules out the reverse strict one: a <= b implies b < a is false.

law lt_of_not_le provedsource · line 1620 · raw

@a:Nat -> @b:Nat -> @h:{Nat.is_le(a, b) == False{} : Bool} -> lt(b, a)

A failed weak test gives the reverse strict order: a <= b false implies b < a.

law le_of_not_lt provedsource · line 1638 · raw

@a:Nat -> @b:Nat -> @h:{Nat.is_lt(a, b) == False{} : Bool} -> le(b, a)

A failed strict test gives the reverse weak order: a < b false implies b <= a.

law lt_min provedsource · line 1656 · raw

@a:Nat -> @b:Nat -> @c:Nat -> @hb:lt(a, b) -> @hc:lt(a, c) -> lt(a, Nat.min(b, c))

A number below both bounds is below their minimum: a < b and a < c imply a < min b c.

law min_le_iff provedsource · line 1690 · raw

@a:Nat -> @b:Nat -> @c:Nat -> {Nat.is_le(Nat.min(a, b), c) == Bool.or(Nat.is_le(a, c), Nat.is_le(b, c)) : Bool}

The minimum is at most c exactly when one argument is: min a b <= c tests as a <= c or b <= c.

law lt_max_iff provedsource · line 1716 · raw

@a:Nat -> @b:Nat -> @c:Nat -> {Nat.is_lt(a, Nat.max(b, c)) == Bool.or(Nat.is_lt(a, b), Nat.is_lt(a, c)) : Bool}

The maximum is above a exactly when one argument is: a < max b c tests as a < b or a < c.

law sub_eq_zero_of_le provedsource · line 1742 · raw

@a:Nat -> @b:Nat -> @h:le(a, b) -> {Nat.sub(a, b) == 0n : Nat}

Subtracting a larger number gives zero: a <= b implies a - b = 0.

law succ_sub provedsource · line 1760 · raw

@a:Nat -> @b:Nat -> @h:le(b, a) -> {Nat.sub(1n+a, b) == 1n+Nat.sub(a, b) : Nat}

Above the subtrahend, a successor subtracts to a successor: b <= a implies (a + 1) - b = (a - b) + 1.

law add_sub_of_le provedsource · line 1778 · raw

@a:Nat -> @b:Nat -> @h:le(a, b) -> {Nat.add(a, Nat.sub(b, a)) == b : Nat}

Adding back what was subtracted restores the number: a <= b implies a + (b - a) = b.

law lt_sub_iff_add_lt provedsource · line 1804 · raw

@a:Nat -> @b:Nat -> @c:Nat -> {Nat.is_lt(a, Nat.sub(c, b)) == Nat.is_lt(Nat.add(b, a), c) : Bool}

Comparing against a difference is comparing the sum: a < c - b tests as b + a < c.

law le_of_add_eq provedsource · line 1822 · raw

@a:Nat -> @k:Nat -> @-b:Nat -> @e:{Nat.add(a, k) == b : Nat} -> le(a, b)

A witnessed difference gives the order: a + k = b implies a <= b.

law mul_le_mul_right provedsource · line 1834 · raw

@+a:Nat -> @+b:Nat -> @+k:Nat -> @h:le(a, b) -> le(Nat.mul(a, k), Nat.mul(b, k))

Multiplying on the right preserves the order: a <= b implies a * k <= b * k.

law zero_div provedsource · line 1848 · raw

@b:Nat -> {Nat.div(0n, b) == 0n : Nat}

Zero divided by anything is zero: 0 / b = 0.

law zero_mod provedsource · line 1860 · raw

@b:Nat -> {Nat.mod(0n, b) == 0n : Nat}

Zero modulo anything is zero: 0 % b = 0.

law div_one provedsource · line 1880 · raw

@a:Nat -> {Nat.div(a, 1n) == a : Nat}

Dividing by one changes nothing: a / 1 = a.

law mod_one provedsource · line 1890 · raw

@a:Nat -> {Nat.mod(a, 1n) == 0n : Nat}

Any natural modulo one is zero: a % 1 = 0.

law mod_self provedsource · line 1907 · raw

@n:Nat -> {Nat.mod(n, n) == 0n : Nat}

A natural modulo itself is zero: n % n = 0.

law div_self provedsource · line 1920 · raw

@b:Nat -> {Nat.div(1n+b, 1n+b) == 1n : Nat}

A positive natural divided by itself is one: (1 + b) / (1 + b) = 1.

law mod_lt provedsource · line 1941 · raw

@a:Nat -> @b:Nat -> lt(Nat.mod(a, 1n+b), 1n+b)

A remainder is below its positive divisor: a % (1 + b) < 1 + b.

law mod_le provedsource · line 1953 · raw

@a:Nat -> @b:Nat -> le(Nat.mod(a, b), a)

A remainder never exceeds the dividend: a % b <= a.

law div_le_self provedsource · line 1973 · raw

@a:Nat -> @b:Nat -> le(Nat.div(a, b), a)

A quotient never exceeds the dividend: a / b <= a.

law mod_eq_of_lt provedsource · line 2002 · raw

@a:Nat -> @b:Nat -> @h:lt(a, b) -> {Nat.mod(a, b) == a : Nat}

A number below the divisor is its own remainder: a < b implies a % b = a.

law mod_mod provedsource · line 2019 · raw

@a:Nat -> @n:Nat -> {Nat.mod(Nat.mod(a, n), n) == Nat.mod(a, n) : Nat}

Taking a remainder twice is taking it once: (a % n) % n = a % n.

law add_mod_left provedsource · line 2043 · raw

@a:Nat -> @b:Nat -> {Nat.mod(Nat.add(b, a), b) == Nat.mod(a, b) : Nat}

Adding the divisor does not change the remainder: (b + a) % b = a % b.

law mul_div_cancel provedsource · line 2059 · raw

@a:Nat -> @b:Nat -> {Nat.div(Nat.mul(a, 1n+b), 1n+b) == a : Nat}

Multiplying by a positive divisor then dividing by it cancels: (a * (1 + b)) / (1 + b) = a.

law mul_div_cancel_left provedsource · line 2075 · raw

@a:Nat -> @b:Nat -> {Nat.div(Nat.mul(1n+b, a), 1n+b) == a : Nat}

Multiplying on the left by a positive divisor then dividing by it cancels: ((1 + b) * a) / (1 + b) = a.

law mul_mod_left provedsource · line 2087 · raw

@a:Nat -> @b:Nat -> {Nat.mod(Nat.mul(a, b), b) == 0n : Nat}

A multiple of b leaves no remainder modulo b: (a * b) % b = 0.

law mul_mod_right provedsource · line 2102 · raw

@a:Nat -> @b:Nat -> {Nat.mod(Nat.mul(a, b), a) == 0n : Nat}

A multiple of a leaves no remainder modulo a: (a * b) % a = 0.

law mod_add_div provedsource · line 2114 · raw

@a:Nat -> @b:Nat -> {Nat.add(Nat.mod(a, b), Nat.mul(b, Nat.div(a, b))) == a : Nat}

The remainder plus the divisor times the quotient is the dividend: a % b + b * (a / b) = a.

law div_mul_le_self provedsource · line 2130 · raw

@a:Nat -> @b:Nat -> le(Nat.mul(Nat.div(a, b), b), a)

The quotient times the divisor never exceeds the dividend: (a / b) * b <= a.

law mul_left_comm provedsource · line 2144 · raw

@a:Nat -> @b:Nat -> @c:Nat -> {Nat.mul(a, Nat.mul(b, c)) == Nat.mul(b, Nat.mul(a, c)) : Nat}

Left commutativity of multiplication: a * (b * c) = b * (a * c).

law mul_right_comm provedsource · line 2159 · raw

@a:Nat -> @b:Nat -> @c:Nat -> {Nat.mul(Nat.mul(a, b), c) == Nat.mul(Nat.mul(a, c), b) : Nat}

Right commutativity of multiplication: (a * b) * c = (a * c) * b.

law mul_mul_mul_comm provedsource · line 2174 · raw

@a:Nat -> @b:Nat -> @c:Nat -> @d:Nat -> {Nat.mul(Nat.mul(a, b), Nat.mul(c, d)) == Nat.mul(Nat.mul(a, c), Nat.mul(b, d)) : Nat}

Four-way regrouping of a product: (a * b) * (c * d) = (a * c) * (b * d).

law zero_pow provedsource · line 2191 · raw

@-n:Nat -> {Nat.pow(0n, 1n+n) == 0n : Nat}

Zero to a positive power is zero: 0^(n+1) = 0.

law mul_pow provedsource · line 2199 · raw

@+a:Nat -> @+b:Nat -> @n:Nat -> {Nat.pow(Nat.mul(a, b), n) == Nat.mul(Nat.pow(a, n), Nat.pow(b, n)) : Nat}

A power of a product is the product of the powers: (a * b)^n = a^n * b^n.

law pow_mul provedsource · line 2214 · raw

@a:Nat -> @m:Nat -> @n:Nat -> {Nat.pow(a, Nat.mul(m, n)) == Nat.pow(Nat.pow(a, m), n) : Nat}

Exponents multiply under repeated powers: a^(m * n) = (a^m)^n.

law one_le_pow provedsource · line 2232 · raw

@n:Nat -> @a:Nat -> le(1n, Nat.pow(1n+a, n))

A power of a positive base is at least one: 1 <= (1 + a)^n.

law pow_pos provedsource · line 2246 · raw

@n:Nat -> @a:Nat -> lt(0n, Nat.pow(1n+a, n))

A power of a positive base is positive: 0 < (1 + a)^n.

law le_add_left provedsource · line 2258 · raw

@n:Nat -> @m:Nat -> le(n, Nat.add(m, n))

Adding on the left never decreases a natural: n <= m + n.

law add_sub_add_left provedsource · line 2272 · raw

@k:Nat -> @-n:Nat -> @-m:Nat -> {Nat.sub(Nat.add(k, n), Nat.add(k, m)) == Nat.sub(n, m) : Nat}

A common left summand cancels in a difference: (k + n) - (k + m) = n - m.

law add_sub_add_right provedsource · line 2286 · raw

@n:Nat -> @k:Nat -> @m:Nat -> {Nat.sub(Nat.add(n, k), Nat.add(m, k)) == Nat.sub(n, m) : Nat}

A common right summand cancels in a difference: (n + k) - (m + k) = n - m.

law add_sub_assoc provedsource · line 2301 · raw

@k:Nat -> @m:Nat -> @h:le(k, m) -> @n:Nat -> {Nat.sub(Nat.add(n, m), k) == Nat.add(n, Nat.sub(m, k)) : Nat}

Subtracting a part of the right summand: k <= m implies (n + m) - k = n + (m - k).

law sub_sub_self provedsource · line 2317 · raw

@n:Nat -> @m:Nat -> @h:le(m, n) -> {Nat.sub(n, Nat.sub(n, m)) == m : Nat}

Subtracting a difference from its minuend: m <= n implies n - (n - m) = m.

law sub_mul provedsource · line 2335 · raw

@n:Nat -> @m:Nat -> @k:Nat -> {Nat.mul(Nat.sub(n, m), k) == Nat.sub(Nat.mul(n, k), Nat.mul(m, k)) : Nat}

Multiplication distributes over subtraction on the right: (n - m) * k = n * k - m * k.

law mul_sub provedsource · line 2354 · raw

@n:Nat -> @m:Nat -> @k:Nat -> {Nat.mul(n, Nat.sub(m, k)) == Nat.sub(Nat.mul(n, m), Nat.mul(n, k)) : Nat}

Multiplication distributes over subtraction on the left: n * (m - k) = n * m - n * k.

law min_eq_left provedsource · line 2370 · raw

@a:Nat -> @b:Nat -> @h:le(a, b) -> {Nat.min(a, b) == a : Nat}

The minimum is the smaller argument on the left: a <= b implies min a b = a.

law min_eq_right provedsource · line 2387 · raw

@a:Nat -> @b:Nat -> @h:le(b, a) -> {Nat.min(a, b) == b : Nat}

The minimum is the smaller argument on the right: b <= a implies min a b = b.

law max_eq_left provedsource · line 2406 · raw

@a:Nat -> @b:Nat -> @h:le(b, a) -> {Nat.max(a, b) == a : Nat}

The maximum is the larger argument on the left: b <= a implies max a b = a.

law max_eq_right provedsource · line 2425 · raw

@a:Nat -> @b:Nat -> @h:le(a, b) -> {Nat.max(a, b) == b : Nat}

The maximum is the larger argument on the right: a <= b implies max a b = b.

law le_min provedsource · line 2456 · raw

@a:Nat -> @b:Nat -> @c:Nat -> {Nat.is_le(a, Nat.min(b, c)) == Bool.and(Nat.is_le(a, b), Nat.is_le(a, c)) : Bool}

A number is at most the minimum exactly when it is at most both: a <= min b c tests as a <= b and a <= c.

law max_le provedsource · line 2480 · raw

@a:Nat -> @b:Nat -> @c:Nat -> {Nat.is_le(Nat.max(a, b), c) == Bool.and(Nat.is_le(a, c), Nat.is_le(b, c)) : Bool}

The maximum is at most c exactly when both arguments are: max a b <= c tests as a <= c and b <= c.

law mul_le_mul_left provedsource · line 2502 · raw

@a:Nat -> @b:Nat -> @k:Nat -> @h:le(a, b) -> le(Nat.mul(k, a), Nat.mul(k, b))

Multiplying on the left preserves the order: a <= b implies k * a <= k * b.

law mul_le_mul provedsource · line 2518 · raw

@a:Nat -> @b:Nat -> @c:Nat -> @d:Nat -> @h1:le(a, c) -> @h2:le(b, d) -> le(Nat.mul(a, b), Nat.mul(c, d))

Multiplying two bounded factors stays bounded: a <= c and b <= d imply a * b <= c * d.

law add_zero_sym provedsource · line 2537 · raw

@x:Nat -> {x == Nat.add(x, 0n) : Nat}

Zero is a right identity for addition: x + 0 = x, reversed to rewrite toward the simple side.

law zero_add_sym provedsource · line 2545 · raw

@-x:Nat -> {x == Nat.add(0n, x) : Nat}

Zero is a left identity for addition: 0 + x = x, reversed to rewrite toward the simple side.

law add_succ_sym provedsource · line 2553 · raw

@n:Nat -> @-m:Nat -> {1n+Nat.add(n, m) == Nat.add(n, 1n+m) : Nat}

Adding a successor on the right: n + (m + 1) = (n + m) + 1, reversed to rewrite toward the simple side.

law succ_add_sym provedsource · line 2562 · raw

@-n:Nat -> @-m:Nat -> {1n+Nat.add(n, m) == Nat.add(1n+n, m) : Nat}

Adding a successor on the left: (n + 1) + m = (n + m) + 1, reversed to rewrite toward the simple side.

law add_comm_sym provedsource · line 2571 · raw

@n:Nat -> @m:Nat -> {Nat.add(m, n) == Nat.add(n, m) : Nat}

Addition is commutative: n + m = m + n, reversed to rewrite toward the simple side.

law add_assoc_sym provedsource · line 2580 · raw

@a:Nat -> @-b:Nat -> @-c:Nat -> {Nat.add(a, Nat.add(b, c)) == Nat.add(Nat.add(a, b), c) : Nat}

Addition is associative: (a + b) + c = a + (b + c), reversed to rewrite toward the simple side.

law add_left_comm_sym provedsource · line 2590 · raw

@a:Nat -> @b:Nat -> @-c:Nat -> {Nat.add(b, Nat.add(a, c)) == Nat.add(a, Nat.add(b, c)) : Nat}

Left commutativity of addition: a + (b + c) = b + (a + c), reversed to rewrite toward the simple side.

law add_right_comm_sym provedsource · line 2600 · raw

@a:Nat -> @b:Nat -> @c:Nat -> {Nat.add(Nat.add(a, c), b) == Nat.add(Nat.add(a, b), c) : Nat}

Right commutativity of addition: (a + b) + c = (a + c) + b, reversed to rewrite toward the simple side.

law add_add_add_comm_sym provedsource · line 2610 · raw

@a:Nat -> @b:Nat -> @c:Nat -> @-d:Nat -> {Nat.add(Nat.add(a, c), Nat.add(b, d)) == Nat.add(Nat.add(a, b), Nat.add(c, d)) : Nat}

Four-way regrouping of a sum: (a + b) + (c + d) = (a + c) + (b + d), reversed to rewrite toward the simple side.

law mul_zero_sym provedsource · line 2621 · raw

@x:Nat -> {0n == Nat.mul(x, 0n) : Nat}

Zero absorbs multiplication on the right: x * 0 = 0, reversed to rewrite toward the simple side.

law zero_mul_sym provedsource · line 2629 · raw

@-x:Nat -> {0n == Nat.mul(0n, x) : Nat}

Zero absorbs multiplication on the left: 0 * x = 0, reversed to rewrite toward the simple side.

law mul_one_sym provedsource · line 2637 · raw

@x:Nat -> {x == Nat.mul(x, 1n) : Nat}

One is a right identity for multiplication: x * 1 = x, reversed to rewrite toward the simple side.

law one_mul_sym provedsource · line 2645 · raw

@x:Nat -> {x == Nat.mul(1n, x) : Nat}

One is a left identity for multiplication: 1 * x = x, reversed to rewrite toward the simple side.

law mul_succ_sym provedsource · line 2653 · raw

@n:Nat -> @m:Nat -> {Nat.add(Nat.mul(n, m), n) == Nat.mul(n, 1n+m) : Nat}

Multiplying by a successor on the right: n * (m + 1) = n * m + n, reversed to rewrite toward the simple side.

law succ_mul_sym provedsource · line 2662 · raw

@n:Nat -> @m:Nat -> {Nat.add(Nat.mul(n, m), m) == Nat.mul(1n+n, m) : Nat}

Multiplying by a successor on the left: (n + 1) * m = n * m + m, reversed to rewrite toward the simple side.

law mul_comm_sym provedsource · line 2671 · raw

@n:Nat -> @m:Nat -> {Nat.mul(m, n) == Nat.mul(n, m) : Nat}

Multiplication is commutative: n * m = m * n, reversed to rewrite toward the simple side.

law add_mul_sym provedsource · line 2680 · raw

@a:Nat -> @-b:Nat -> @c:Nat -> {Nat.add(Nat.mul(a, c), Nat.mul(b, c)) == Nat.mul(Nat.add(a, b), c) : Nat}

Multiplication distributes over addition on the right: (a + b) * c = a * c + b * c, reversed to rewrite toward the simple side.

law mul_add_sym provedsource · line 2690 · raw

@a:Nat -> @b:Nat -> @c:Nat -> {Nat.add(Nat.mul(a, b), Nat.mul(a, c)) == Nat.mul(a, Nat.add(b, c)) : Nat}

Multiplication distributes over addition on the left: a * (b + c) = a * b + a * c, reversed to rewrite toward the simple side.

law mul_assoc_sym provedsource · line 2700 · raw

@a:Nat -> @b:Nat -> @c:Nat -> {Nat.mul(a, Nat.mul(b, c)) == Nat.mul(Nat.mul(a, b), c) : Nat}

Multiplication is associative: (a * b) * c = a * (b * c), reversed to rewrite toward the simple side.

law sub_zero_sym provedsource · line 2710 · raw

@n:Nat -> {n == Nat.sub(n, 0n) : Nat}

Subtracting zero changes nothing: n - 0 = n, reversed to rewrite toward the simple side.

law zero_sub_sym provedsource · line 2718 · raw

@n:Nat -> {0n == Nat.sub(0n, n) : Nat}

Truncated subtraction from zero is zero: 0 - n = 0, reversed to rewrite toward the simple side.

law sub_self_sym provedsource · line 2726 · raw

@n:Nat -> {0n == Nat.sub(n, n) : Nat}

A natural minus itself is zero: n - n = 0, reversed to rewrite toward the simple side.

law succ_sub_succ_sym provedsource · line 2734 · raw

@-n:Nat -> @-m:Nat -> {Nat.sub(n, m) == Nat.sub(1n+n, 1n+m) : Nat}

Subtracting successors: (n + 1) - (m + 1) = n - m, reversed to rewrite toward the simple side.

law add_sub_cancel_sym provedsource · line 2743 · raw

@n:Nat -> @m:Nat -> {n == Nat.sub(Nat.add(n, m), m) : Nat}

Adding then subtracting m cancels: (n + m) - m = n, reversed to rewrite toward the simple side.

law add_sub_cancel_left_sym provedsource · line 2752 · raw

@n:Nat -> @m:Nat -> {m == Nat.sub(Nat.add(n, m), n) : Nat}

Adding then subtracting n cancels: (n + m) - n = m, reversed to rewrite toward the simple side.

law sub_sub_sym provedsource · line 2761 · raw

@n:Nat -> @m:Nat -> @k:Nat -> {Nat.sub(n, Nat.add(m, k)) == Nat.sub(Nat.sub(n, m), k) : Nat}

Subtracting twice is subtracting the sum: (n - m) - k = n - (m + k), reversed to rewrite toward the simple side.

law div_mod_eq_sym provedsource · line 2771 · raw

@+a:Nat -> @+b:Nat -> {a == Nat.add(Nat.mul(Nat.div(a, 1n+b), 1n+b), Nat.mod(a, 1n+b)) : Nat}

The division equation, for a positive divisor 1 + b: (a / (1 + b)) * (1 + b) + a % (1 + b) = a, reversed to rewrite toward the simple side.

law add_div_left_sym provedsource · line 2780 · raw

@+a:Nat -> @+b:Nat -> {1n+Nat.div(a, 1n+b) == Nat.div(Nat.add(1n+b, a), 1n+b) : Nat}

Adding the divisor adds one to the quotient: ((1 + b) + a) / (1 + b) = 1 + a / (1 + b), reversed to rewrite toward the simple side.

law le_div_iff_mul_le_sym provedsource · line 2789 · raw

@n:Nat -> @+a:Nat -> @+b:Nat -> {Nat.is_le(Nat.mul(n, 1n+b), a) == Nat.is_le(n, Nat.div(a, 1n+b)) : Bool}

A quotient is compared by multiplying back: n <= a / (1 + b) tests as n * (1 + b) <= a, reversed to rewrite toward the simple side.

law min_comm_sym provedsource · line 2799 · raw

@a:Nat -> @b:Nat -> {Nat.min(b, a) == Nat.min(a, b) : Nat}

Minimum is commutative, reversed to rewrite toward the simple side.

law max_comm_sym provedsource · line 2808 · raw

@a:Nat -> @b:Nat -> {Nat.max(b, a) == Nat.max(a, b) : Nat}

Maximum is commutative, reversed to rewrite toward the simple side.

law min_self_sym provedsource · line 2817 · raw

@a:Nat -> {a == Nat.min(a, a) : Nat}

The minimum of a natural and itself is itself, reversed to rewrite toward the simple side.

law max_self_sym provedsource · line 2825 · raw

@a:Nat -> {a == Nat.max(a, a) : Nat}

The maximum of a natural and itself is itself, reversed to rewrite toward the simple side.

law min_zero_sym provedsource · line 2833 · raw

@a:Nat -> {0n == Nat.min(a, 0n) : Nat}

The minimum with zero is zero: min(a, 0) = 0, reversed to rewrite toward the simple side.

law zero_min_sym provedsource · line 2841 · raw

@a:Nat -> {0n == Nat.min(0n, a) : Nat}

The minimum with zero is zero: min(0, a) = 0, reversed to rewrite toward the simple side.

law max_zero_sym provedsource · line 2849 · raw

@a:Nat -> {a == Nat.max(a, 0n) : Nat}

Zero is an identity for maximum: max(a, 0) = a, reversed to rewrite toward the simple side.

law zero_max_sym provedsource · line 2857 · raw

@a:Nat -> {a == Nat.max(0n, a) : Nat}

Zero is an identity for maximum: max(0, a) = a, reversed to rewrite toward the simple side.

law min_assoc_sym provedsource · line 2865 · raw

@a:Nat -> @b:Nat -> @c:Nat -> {Nat.min(a, Nat.min(b, c)) == Nat.min(Nat.min(a, b), c) : Nat}

Minimum is associative, reversed to rewrite toward the simple side.

law max_assoc_sym provedsource · line 2875 · raw

@a:Nat -> @b:Nat -> @c:Nat -> {Nat.max(a, Nat.max(b, c)) == Nat.max(Nat.max(a, b), c) : Nat}

Maximum is associative, reversed to rewrite toward the simple side.

law min_add_max_sym provedsource · line 2885 · raw

@a:Nat -> @b:Nat -> {Nat.add(a, b) == Nat.add(Nat.min(a, b), Nat.max(a, b)) : Nat}

The minimum plus the maximum is the sum: min(a, b) + max(a, b) = a + b, reversed to rewrite toward the simple side.

law pow_zero_sym provedsource · line 2894 · raw

@-a:Nat -> {1n == Nat.pow(a, 0n) : Nat}

Any natural to the power zero is one, reversed to rewrite toward the simple side.

law pow_succ_sym provedsource · line 2902 · raw

@-a:Nat -> @-n:Nat -> {Nat.mul(a, Nat.pow(a, n)) == Nat.pow(a, 1n+n) : Nat}

A power with a successor exponent: a^(n+1) = a * a^n, reversed to rewrite toward the simple side.

law pow_one_sym provedsource · line 2911 · raw

@a:Nat -> {a == Nat.pow(a, 1n) : Nat}

Any natural to the power one is itself, reversed to rewrite toward the simple side.

law one_pow_sym provedsource · line 2919 · raw

@n:Nat -> {1n == Nat.pow(1n, n) : Nat}

One to any power is one, reversed to rewrite toward the simple side.

law pow_add_sym provedsource · line 2927 · raw

@a:Nat -> @m:Nat -> @n:Nat -> {Nat.mul(Nat.pow(a, m), Nat.pow(a, n)) == Nat.pow(a, Nat.add(m, n)) : Nat}

Exponents add under multiplication: a^(m+n) = a^m * a^n, reversed to rewrite toward the simple side.

law double_eq_add_sym provedsource · line 2937 · raw

@n:Nat -> {Nat.add(n, n) == Nat.double(n) : Nat}

Doubling is adding a natural to itself, reversed to rewrite toward the simple side.

law is_eq_refl_sym provedsource · line 2945 · raw

@n:Nat -> {True{} == Nat.is_eq(n, n) : Bool}

Every natural tests equal to itself, reversed to rewrite toward the simple side.

law is_eq_comm_sym provedsource · line 2953 · raw

@a:Nat -> @b:Nat -> {Nat.is_eq(b, a) == Nat.is_eq(a, b) : Bool}

The equality test is symmetric, reversed to rewrite toward the simple side.

law is_ge_eq_is_le_sym provedsource · line 2962 · raw

@a:Nat -> @b:Nat -> {Nat.is_le(b, a) == Nat.is_ge(a, b) : Bool}

A >= b tests the same as b <= a, reversed to rewrite toward the simple side.

law is_gt_eq_is_lt_sym provedsource · line 2971 · raw

@a:Nat -> @b:Nat -> {Nat.is_lt(b, a) == Nat.is_gt(a, b) : Bool}

A > b tests the same as b < a, reversed to rewrite toward the simple side.

law is_lt_eq_succ_le_sym provedsource · line 2980 · raw

@a:Nat -> @b:Nat -> {Nat.is_le(1n+a, b) == Nat.is_lt(a, b) : Bool}

A < b tests the same as a + 1 <= b, reversed to rewrite toward the simple side.

law not_is_le_sym provedsource · line 2989 · raw

@a:Nat -> @b:Nat -> {Nat.is_lt(b, a) == Bool.not(Nat.is_le(a, b)) : Bool}

Not (a <= b) tests the same as b < a, reversed to rewrite toward the simple side.

law not_is_lt_sym provedsource · line 2998 · raw

@a:Nat -> @b:Nat -> {Nat.is_le(b, a) == Bool.not(Nat.is_lt(a, b)) : Bool}

Not (a < b) tests the same as b <= a, reversed to rewrite toward the simple side.

law add_le_add_iff_left_sym provedsource · line 3007 · raw

@k:Nat -> @-a:Nat -> @-b:Nat -> {Nat.is_le(Nat.add(k, a), Nat.add(k, b)) == Nat.is_le(a, b) : Bool}

Adding the same amount on the left does not change the order test: a <= b tests as k + a <= k + b, reversed to rewrite toward the simple side.

law le_and_le_sub_iff_add_le_sym provedsource · line 3017 · raw

@a:Nat -> @-b:Nat -> @c:Nat -> {Nat.is_le(Nat.add(a, b), c) == Bool.and(Nat.is_le(a, c), Nat.is_le(b, Nat.sub(c, a))) : Bool}

A sum is at most c exactly when a <= c and b <= c - a: a + b <= c tests as both, reversed to rewrite toward the simple side.

law min_le_iff_sym provedsource · line 3027 · raw

@a:Nat -> @b:Nat -> @c:Nat -> {Bool.or(Nat.is_le(a, c), Nat.is_le(b, c)) == Nat.is_le(Nat.min(a, b), c) : Bool}

The minimum is at most c exactly when one argument is: min a b <= c tests as a <= c or b <= c, reversed to rewrite toward the simple side.

law lt_max_iff_sym provedsource · line 3037 · raw

@a:Nat -> @b:Nat -> @c:Nat -> {Bool.or(Nat.is_lt(a, b), Nat.is_lt(a, c)) == Nat.is_lt(a, Nat.max(b, c)) : Bool}

The maximum is above a exactly when one argument is: a < max b c tests as a < b or a < c, reversed to rewrite toward the simple side.

law lt_sub_iff_add_lt_sym provedsource · line 3047 · raw

@a:Nat -> @b:Nat -> @c:Nat -> {Nat.is_lt(Nat.add(b, a), c) == Nat.is_lt(a, Nat.sub(c, b)) : Bool}

Comparing against a difference is comparing the sum: a < c - b tests as b + a < c, reversed to rewrite toward the simple side.

law zero_div_sym provedsource · line 3057 · raw

@b:Nat -> {0n == Nat.div(0n, b) : Nat}

Zero divided by anything is zero: 0 / b = 0, reversed to rewrite toward the simple side.

law zero_mod_sym provedsource · line 3065 · raw

@b:Nat -> {0n == Nat.mod(0n, b) : Nat}

Zero modulo anything is zero: 0 % b = 0, reversed to rewrite toward the simple side.

law div_one_sym provedsource · line 3073 · raw

@a:Nat -> {a == Nat.div(a, 1n) : Nat}

Dividing by one changes nothing: a / 1 = a, reversed to rewrite toward the simple side.

law mod_one_sym provedsource · line 3081 · raw

@a:Nat -> {0n == Nat.mod(a, 1n) : Nat}

Any natural modulo one is zero: a % 1 = 0, reversed to rewrite toward the simple side.

law mod_self_sym provedsource · line 3089 · raw

@n:Nat -> {0n == Nat.mod(n, n) : Nat}

A natural modulo itself is zero: n % n = 0, reversed to rewrite toward the simple side.

law div_self_sym provedsource · line 3097 · raw

@b:Nat -> {1n == Nat.div(1n+b, 1n+b) : Nat}

A positive natural divided by itself is one: (1 + b) / (1 + b) = 1, reversed to rewrite toward the simple side.

law mod_mod_sym provedsource · line 3105 · raw

@a:Nat -> @n:Nat -> {Nat.mod(a, n) == Nat.mod(Nat.mod(a, n), n) : Nat}

Taking a remainder twice is taking it once: (a % n) % n = a % n, reversed to rewrite toward the simple side.

law add_mod_left_sym provedsource · line 3114 · raw

@a:Nat -> @b:Nat -> {Nat.mod(a, b) == Nat.mod(Nat.add(b, a), b) : Nat}

Adding the divisor does not change the remainder: (b + a) % b = a % b, reversed to rewrite toward the simple side.

law mul_div_cancel_sym provedsource · line 3123 · raw

@a:Nat -> @b:Nat -> {a == Nat.div(Nat.mul(a, 1n+b), 1n+b) : Nat}

Multiplying by a positive divisor then dividing by it cancels: (a * (1 + b)) / (1 + b) = a, reversed to rewrite toward the simple side.

law mul_div_cancel_left_sym provedsource · line 3132 · raw

@a:Nat -> @b:Nat -> {a == Nat.div(Nat.mul(1n+b, a), 1n+b) : Nat}

Multiplying on the left by a positive divisor then dividing by it cancels: ((1 + b) * a) / (1 + b) = a, reversed to rewrite toward the simple side.

law mul_mod_left_sym provedsource · line 3141 · raw

@a:Nat -> @b:Nat -> {0n == Nat.mod(Nat.mul(a, b), b) : Nat}

A multiple of b leaves no remainder modulo b: (a * b) % b = 0, reversed to rewrite toward the simple side.

law mul_mod_right_sym provedsource · line 3150 · raw

@a:Nat -> @b:Nat -> {0n == Nat.mod(Nat.mul(a, b), a) : Nat}

A multiple of a leaves no remainder modulo a: (a * b) % a = 0, reversed to rewrite toward the simple side.

law mod_add_div_sym provedsource · line 3159 · raw

@a:Nat -> @b:Nat -> {a == Nat.add(Nat.mod(a, b), Nat.mul(b, Nat.div(a, b))) : Nat}

The remainder plus the divisor times the quotient is the dividend: a % b + b * (a / b) = a, reversed to rewrite toward the simple side.

law mul_left_comm_sym provedsource · line 3168 · raw

@a:Nat -> @b:Nat -> @c:Nat -> {Nat.mul(b, Nat.mul(a, c)) == Nat.mul(a, Nat.mul(b, c)) : Nat}

Left commutativity of multiplication: a * (b * c) = b * (a * c), reversed to rewrite toward the simple side.

law mul_right_comm_sym provedsource · line 3178 · raw

@a:Nat -> @b:Nat -> @c:Nat -> {Nat.mul(Nat.mul(a, c), b) == Nat.mul(Nat.mul(a, b), c) : Nat}

Right commutativity of multiplication: (a * b) * c = (a * c) * b, reversed to rewrite toward the simple side.

law mul_mul_mul_comm_sym provedsource · line 3188 · raw

@a:Nat -> @b:Nat -> @c:Nat -> @d:Nat -> {Nat.mul(Nat.mul(a, c), Nat.mul(b, d)) == Nat.mul(Nat.mul(a, b), Nat.mul(c, d)) : Nat}

Four-way regrouping of a product: (a * b) * (c * d) = (a * c) * (b * d), reversed to rewrite toward the simple side.

law zero_pow_sym provedsource · line 3199 · raw

@-n:Nat -> {0n == Nat.pow(0n, 1n+n) : Nat}

Zero to a positive power is zero: 0^(n+1) = 0, reversed to rewrite toward the simple side.

law mul_pow_sym provedsource · line 3207 · raw

@+a:Nat -> @+b:Nat -> @n:Nat -> {Nat.mul(Nat.pow(a, n), Nat.pow(b, n)) == Nat.pow(Nat.mul(a, b), n) : Nat}

A power of a product is the product of the powers: (a * b)^n = a^n * b^n, reversed to rewrite toward the simple side.

law pow_mul_sym provedsource · line 3217 · raw

@a:Nat -> @m:Nat -> @n:Nat -> {Nat.pow(Nat.pow(a, m), n) == Nat.pow(a, Nat.mul(m, n)) : Nat}

Exponents multiply under repeated powers: a^(m * n) = (a^m)^n, reversed to rewrite toward the simple side.

law add_sub_add_left_sym provedsource · line 3227 · raw

@k:Nat -> @-n:Nat -> @-m:Nat -> {Nat.sub(n, m) == Nat.sub(Nat.add(k, n), Nat.add(k, m)) : Nat}

A common left summand cancels in a difference: (k + n) - (k + m) = n - m, reversed to rewrite toward the simple side.

law add_sub_add_right_sym provedsource · line 3237 · raw

@n:Nat -> @k:Nat -> @m:Nat -> {Nat.sub(n, m) == Nat.sub(Nat.add(n, k), Nat.add(m, k)) : Nat}

A common right summand cancels in a difference: (n + k) - (m + k) = n - m, reversed to rewrite toward the simple side.

law sub_mul_sym provedsource · line 3247 · raw

@n:Nat -> @m:Nat -> @k:Nat -> {Nat.sub(Nat.mul(n, k), Nat.mul(m, k)) == Nat.mul(Nat.sub(n, m), k) : Nat}

Multiplication distributes over subtraction on the right: (n - m) * k = n * k - m * k, reversed to rewrite toward the simple side.

law mul_sub_sym provedsource · line 3257 · raw

@n:Nat -> @m:Nat -> @k:Nat -> {Nat.sub(Nat.mul(n, m), Nat.mul(n, k)) == Nat.mul(n, Nat.sub(m, k)) : Nat}

Multiplication distributes over subtraction on the left: n * (m - k) = n * m - n * k, reversed to rewrite toward the simple side.

law le_min_sym provedsource · line 3267 · raw

@a:Nat -> @b:Nat -> @c:Nat -> {Bool.and(Nat.is_le(a, b), Nat.is_le(a, c)) == Nat.is_le(a, Nat.min(b, c)) : Bool}

A number is at most the minimum exactly when it is at most both: a <= min b c tests as a <= b and a <= c, reversed to rewrite toward the simple side.

law max_le_sym provedsource · line 3277 · raw

@a:Nat -> @b:Nat -> @c:Nat -> {Bool.and(Nat.is_le(a, c), Nat.is_le(b, c)) == Nat.is_le(Nat.max(a, b), c) : Bool}

The maximum is at most c exactly when both arguments are: max a b <= c tests as a <= c and b <= c, reversed to rewrite toward the simple side.

Definitions

def internal_pred source · line 133 · raw

@n:Nat -> Nat

def internal_zero_ne_succ source · line 151 · raw

@-n:Nat -> @e:{0n == 1n+n : Nat} -> Empty

def internal_succ_ne_zero source · line 163 · raw

@-n:Nat -> @e:{1n+n == 0n : Nat} -> Empty

def le source · line 339 · raw

@a:Nat -> @b:Nat -> Data

The order a <= b on naturals, as a reusable proposition.

def lt source · line 343 · raw

@a:Nat -> @b:Nat -> Data

The strict order a < b on naturals, as a reusable proposition.

def ge source · line 347 · raw

@a:Nat -> @b:Nat -> Data

The order a >= b on naturals, as a reusable proposition.

def gt source · line 351 · raw

@a:Nat -> @b:Nat -> Data

The strict order a > b on naturals, as a reusable proposition.

def internal_false_ne_true source · line 354 · raw

@e:{False{} == True{} : Bool} -> Empty

def internal_div_true_ne_false source · line 740 · raw

@h:{True{} == False{} : Bool} -> Empty

def internal_div_add_zero_r source · line 743 · raw

@a:Nat -> {a == Nat.add(a, 0n) : Nat}

def internal_div_le_refl source · line 746 · raw

@a:Nat -> {True{} == Nat.is_le(a, a) : Bool}

def internal_div_zero_le source · line 749 · raw

@x:Nat -> {True{} == Nat.is_le(0n, x) : Bool}

def internal_div_block_start source · line 752 · raw

@-bp:Nat -> @+r:Nat -> @h:{bp == Nat.add(r, 0n) : Nat} -> {bp == r : Nat}

def internal_div_block_step source · line 756 · raw

@-bp:Nat -> @r:Nat -> @-mp:Nat -> @h:{bp == Nat.add(r, 1n+mp) : Nat} -> {bp == 1n+Nat.add(r, mp) : Nat}

def internal_div_go_eq source · line 760 · raw

@n:Nat -> @m:Nat -> @+bp:Nat -> @+d:Nat -> @+r:Nat -> @+h:{bp == Nat.add(r, m) : Nat} -> {Nat.add(Nat.mul(Pair.fst(Nat, Nat, Nat.divmod.go(n, m, d, r)), 1n+bp), Pair.snd(Nat, Nat, Nat.divmod.go(n, m, d, r))) == Nat.add(n, Nat.add(Nat.mul(d, 1n+bp), r)) : Nat}

def internal_div_wit_succ source · line 785 · raw

@+ap:Nat -> @+bq:Nat -> @w:(&k:Nat -> {Nat.add(ap, k) == bq : Nat}) -> &k:Nat -> {Nat.add(1n+ap, k) == 1n+bq : Nat}

def internal_div_le_wit source · line 790 · raw

@a:Nat -> @b:Nat -> @h:{Nat.is_le(a, b) == True{} : Bool} -> &k:Nat -> {Nat.add(a, k) == b : Nat}

def internal_div_go_small source · line 799 · raw

@n:Nat -> @+k:Nat -> @+d:Nat -> @r:Nat -> {d == Pair.fst(Nat, Nat, Nat.divmod.go(n, Nat.add(n, k), d, r)) : Nat}

def internal_div_zero_of_wit source · line 806 · raw

@+a:Nat -> @+b:Nat -> @w:(&k:Nat -> {Nat.add(a, k) == b : Nat}) -> {Nat.div(a, 1n+b) == 0n : Nat}

def internal_div_le_succ_r source · line 822 · raw

@j:Nat -> @d:Nat -> @h:{True{} == Nat.is_le(j, d) : Bool} -> {True{} == Nat.is_le(j, 1n+d) : Bool}

def internal_div_go_d_ge source · line 831 · raw

@+j:Nat -> @n:Nat -> @m:Nat -> @+d:Nat -> @r:Nat -> @h:{True{} == Nat.is_le(j, d) : Bool} -> {True{} == Nat.is_le(j, Pair.fst(Nat, Nat, Nat.divmod.go(n, m, d, r))) : Bool}

def internal_div_mono_go source · line 840 · raw

@a:Nat -> @m:Nat -> @+d:Nat -> @r:Nat -> @+k:Nat -> {True{} == Nat.is_le(Pair.fst(Nat, Nat, Nat.divmod.go(a, m, d, r)), Pair.fst(Nat, Nat, Nat.divmod.go(Nat.add(a, k), m, d, r))) : Bool}

def internal_div_mono_wit source · line 849 · raw

@+a:Nat -> @+c:Nat -> @b:Nat -> @w:(&k:Nat -> {Nat.add(a, k) == c : Nat}) -> le(Nat.div(a, 1n+b), Nat.div(c, 1n+b))

def internal_div_go_shift source · line 866 · raw

@n:Nat -> @m:Nat -> @+d:Nat -> @+r:Nat -> {1n+Pair.fst(Nat, Nat, Nat.divmod.go(n, m, d, r)) == Pair.fst(Nat, Nat, Nat.divmod.go(n, m, 1n+d, r)) : Nat}

def internal_div_go_run source · line 875 · raw

@m:Nat -> @+a:Nat -> @+d:Nat -> @+r:Nat -> {Nat.divmod.go(a, Nat.add(m, r), 1n+d, 0n) == Nat.divmod.go(Nat.add(1n+m, a), m, d, r) : Pair(Nat, Nat)}

def internal_div_le_add_cancel source · line 894 · raw

@t:Nat -> @+x:Nat -> @+y:Nat -> {Nat.is_le(x, y) == Nat.is_le(Nat.add(t, x), Nat.add(t, y)) : Bool}

def internal_div_gt_add source · line 901 · raw

@a:Nat -> @+y:Nat -> {False{} == Nat.is_le(1n+Nat.add(a, y), a) : Bool}

def internal_div_not_succ_le source · line 908 · raw

@a:Nat -> @bp:Nat -> @h:{False{} == Nat.is_le(1n+bp, a) : Bool} -> {Nat.is_le(a, bp) == True{} : Bool}

def internal_div_le_big source · line 917 · raw

@+np:Nat -> @+a:Nat -> @+bp:Nat -> @w:(&k:Nat -> {Nat.add(1n+bp, k) == a : Nat}) -> @ih:(@x:Nat -> {Nat.is_le(np, Nat.div(x, 1n+bp)) == Nat.is_le(Nat.mul(np, 1n+bp), x) : Bool}) -> {Nat.is_le(1n+np, Nat.div(a, 1n+bp)) == Nat.is_le(Nat.mul(1n+np, 1n+bp), a) : Bool}

def internal_div_le_small source · line 925 · raw

@+np:Nat -> @+a:Nat -> @+bp:Nat -> @w:(&k:Nat -> {Nat.add(a, k) == bp : Nat}) -> {Nat.is_le(1n+np, Nat.div(a, 1n+bp)) == Nat.is_le(Nat.mul(1n+np, 1n+bp), a) : Bool}

def internal_div_le_step source · line 933 · raw

@+np:Nat -> @+a:Nat -> @+bp:Nat -> @b:Bool -> @eb:{b == Nat.is_le(1n+bp, a) : Bool} -> @ih:(@x:Nat -> {Nat.is_le(np, Nat.div(x, 1n+bp)) == Nat.is_le(Nat.mul(np, 1n+bp), x) : Bool}) -> {Nat.is_le(1n+np, Nat.div(a, 1n+bp)) == Nat.is_le(Nat.mul(1n+np, 1n+bp), a) : Bool}

def internal_or_true_sym source · line 1675 · raw

@x:Bool -> {True{} == Bool.or(x, True{}) : Bool}

def internal_or_false_sym source · line 1682 · raw

@x:Bool -> {x == Bool.or(x, False{}) : Bool}

def internal_lt_sub_zero source · line 1796 · raw

@a:Nat -> @p:Nat -> {Nat.is_lt(a, Nat.sub(0n, 1n+p)) == Nat.is_lt(Nat.add(1n+p, a), 0n) : Bool}

def internal_div_go_one source · line 1871 · raw

@a:Nat -> @+d:Nat -> {(Nat.add(a, d), 0n) == Nat.divmod.go(a, 0n, d, 0n) : Pair(Nat, Nat)}

def internal_div_go_self source · line 1899 · raw

@m:Nat -> @-d:Nat -> @-r:Nat -> {(1n+d, 0n) == Nat.divmod.go(1n+m, m, d, r) : Pair(Nat, Nat)}

def internal_mod_go_le source · line 1929 · raw

@n:Nat -> @m:Nat -> @-d:Nat -> @+r:Nat -> le(Pair.snd(Nat, Nat, Nat.divmod.go(n, m, d, r)), Nat.add(r, m))

def internal_div_le_self_eq source · line 1967 · raw

@+q:Nat -> @+bp:Nat -> @+m:Nat -> @-a:Nat -> @e:{Nat.add(Nat.mul(q, 1n+bp), m) == a : Nat} -> {Nat.add(q, Nat.add(Nat.mul(bp, q), m)) == a : Nat}

def internal_mod_go_small source · line 1987 · raw

@n:Nat -> @-k:Nat -> @-d:Nat -> @+r:Nat -> {Pair.snd(Nat, Nat, Nat.divmod.go(n, Nat.add(n, k), d, r)) == Nat.add(n, r) : Nat}

def internal_mod_eq_of_wit source · line 1995 · raw

@+a:Nat -> @+b:Nat -> @w:(&k:Nat -> {Nat.add(a, k) == b : Nat}) -> {Nat.mod(a, 1n+b) == a : Nat}

def internal_mod_go_d source · line 2033 · raw

@n:Nat -> @m:Nat -> @-d:Nat -> @-e:Nat -> @r:Nat -> {Pair.snd(Nat, Nat, Nat.divmod.go(n, m, d, r)) == Pair.snd(Nat, Nat, Nat.divmod.go(n, m, e, r)) : Nat}

def internal_and_false_sym source · line 2441 · raw

@x:Bool -> {False{} == Bool.and(x, False{}) : Bool}

def internal_and_true_sym source · line 2448 · raw

@x:Bool -> {x == Bool.and(x, True{}) : Bool}