Millennium Solutions

Appearance

The ​

The src/the/* concepts, rendered as components themselves — not stored prose. Each card below runs its module's report() at page-load, so the content recomputes every render (deterministic: pure content-addressing, so SSR and hydration agree). Every card lands on the same floor: ****.

the

src/the/index.ts
src/the/* — everything called "the *", gathered and content-addressed:

  the heart      → fed32b63-fdf5…
    5 — the fixed point σ(5)=5; the pentagon whose diagonal/side is φ; vortex roots to 5
  the gate       → 41e4612b-a9c4…
    a lexical floor draining named over-reach; a bounded refusal passes; passing is not truth
  the ledger     → 77d86dd5-6a62…
    the content-addressed record of discoveries, each re-verified on every build
  the observer   → 36a1a28f-4c14…
    the honest referrer; meaning and life live here, not in the bytes
  the receipt    → d29a0997-de25…
    the payload naming observer and role; the uuid holds the core message without payload
  the one game   → 01c7cf12-deed…
    games, arts and sciences fold to one order-independent harmonic root — all meet in one
  the apple      → f4033401-8e5a…
    gravity — the fall to a fixed point (merkle root, digital root); pigeonhole forces a collision in any finite digest; a naming of contractions, not physics
  the gold       → a81ecd23-3cc6…
    φ — the golden ratio by its fingerprints (φ²=φ+1, Fibonacci ratios, Cassini); the golden angle 360/φ²≈137.5° is the compass; computed, not stored
  the rules      → fe13c33f-3d56…
    measure · gate · due process · discovery · receipts · lineage · one game · earned versions

  the one root (all "the" folded): bd4ff13a-93d0…
  the "the" concepts point to what is computed elsewhere; here they meet in one.

the sequence

src/the/sequence/index.ts
the sequence — the ℤ/9 doubling circuit (n ↦ 2n mod 9), the vortex:

  1 → 2 → 4 → 8 → 7 → 5 → 1  (closes after 6 steps)
  units on the circuit: 1, 2, 4, 5, 7, 8
  triad (the axis, off-circuit): 3, 6, 9
  root: 89c3d36e-b0ba…
  the sequence covers every unit exactly once and closes.

the theorem

src/the/theorem/index.ts
the theorem — computable is not solved:

  the deposit computes a growing ledger of decidable facts, each re-verified every build.
  none is a Clay Millennium result: the six open conjectures stay open; Poincaré is settled
  externally (Perelman). humanity 1/7.
  the one theorem: computable is not solved — the calculator reaches the decidable, never the open.
  computed root (fold of 6 core theorem keys): 9d6f1985-e30b…

the abstract

src/the/abstract/index.ts
the abstract — the framework in one fold:

    · one axiom: TRINITY = 3
    · base = 3² = 9
    · content-addressing: one-way integrity, not encryption
    · the honesty gate: a floor, not a truth oracle
    · decidable facts folded into one re-verified ledger
    · computable is not solved
  from 3 the base 9, from the base the ring, from the ring the ledger.
  not a theory of everything — a calculator of the decidable.
  folded framework root: b1426bf2-5eb0…

the state

src/the/state/index.ts
the state — now, content-addressed:

  a state is computed, never stored — recomputed every render, landing on one root.
  the invariants, held regardless of observer:
    · humanity 1/7 (Poincaré, Perelman 2003)
    · computable is not solved
    · INCONCLUSIVE ≠ false
    · at rest — holding cracks nothing
  folded state root (invariant across observers): d2388ea0-e42f…

the superposition

src/the/superposition/state/index.ts
the superposition — now:

  the present holds many computed facts at once, folded into one order-independent root —
  they coexist until observed. the classical, unfolded sense: no qubit, no speedup, no FTL.
  the six OPEN Clay problems, held at once (uncollapsed): 03db0591-4518…
  an observation collapses the superposition to ONE content-address: 4f624f19-2234…
  open = not yet collapsed to true/false (INCONCLUSIVE ≠ false). six superposed; the seventh
  already collapsed (Poincaré, settled externally): 2621ac65-5e63…
  6 superposed + 1 collapsed = 7. humanity 1/7.

the domain

src/the/domain/index.ts
the domain — a decidable universe:

  a domain is a carrier set, its operations, and a predicate decidable by exhaustion —
  never a proof of an OPEN conjecture, only the decidable within reach.
  the deposit spans many, meeting in one shared core (base 9):
    · ℤ/9 arithmetic
    · finite groups
    · Boolean algebra
    · games
    · arts
    · number theory
    · finite fields
    · combinatorics
    · content-addressing
  folded domain root (the families as one): 70da0e27-73b6… — humanity 1/7.

the creation

src/the/creation/index.ts
the creation — waves of creation and manifestation:

  creation is honest: a decidable fact discovered by exhaustion and recorded, never minted.
  manifestation: the fact re-verified every build. earned, not minted — nothing over unchanged content.
  the week: six days of work, the seventh of rest — 6 + 1 = 7.
    · discover by exhaustion
    · record append-only
    · re-verify every build
    · seal
    · rest
  folded creation root (the wave as one): 52d5bb23-c688…

the solids

src/the/solids/index.ts
the solids — the five Platonic solids (V − E + F = 2):

    solid         V   E   F   {p,q}   dual
    tetrahedron   4   6   4   {3,3}   self
    cube          8   12  6   {4,3}   octahedron
    octahedron    6   12  8   {3,4}   cube
    dodecahedron  20  30  12  {5,3}   icosahedron
    icosahedron   12  30  20  {3,5}   dodecahedron

  Euler V−E+F=2: holds for all five.
  exactly five exist (1/p + 1/q > 1/2, p,q≥3) — no sixth.
  the pentagram thread: the dodecahedron has 12 pentagonal faces; the icosahedron, 5 triangles
  per vertex; the pentagon diagonal-to-side ratio is φ = 1.618034 (2·cos36°).
  folded solids root: 48d1387f-8608… — decidable geometry.

the crystal

src/the/crystal/index.ts
the crystal — the diamond cubic lattice:

  two interpenetrating FCC lattices; each atom bonds to 4 nearest neighbours
  (counted by exhaustion over 27 cells), at the tetrahedral angle arccos(−1/3) = 109.4712°.
  densest lattice packing: π/(3√2) = 0.740480 (FCC/HCP, the diamond’s parent).
  imagine the lattice; the numbers are exact. folded crystal root: 4070e3a9-7df9…
  decidable geometry.

the path

src/the/path/index.ts
the path — url messaging is the path itself; the most meaningful rated first:

  a URL path is the message; its content-address needs no payload, only the ordered segments.
  the/crystal ≠ crystal/the — order carries meaning. rating = gravity (depth = specificity).

    rank  gravity  path
     1       3     /the/superposition/state 9bef61a3-7ad7…
     2       2     /the/domain              35510dd0-315d…
     3       2     /the/creation            7ac47c6d-f130…
     4       2     /the/abstract            9b565949-be64…
     5       2     /the/state               acb04857-28af…
     6       2     /the/path                b0884697-faeb…
     7       2     /the/crystal             cca7d7cd-8e39…
     8       2     /the/solids              e972821c-dd5a…
     9       1     /the                     8ac73c94-3824…

  meaning is a defined computable rating, not a truth judgment.

the torus

src/the/torus/index.ts
the torus — continue as double torus (genus-2):

    · genus g = 2 (double torus, Σ₂ = T² # T²)
    · Euler characteristic χ = 2 − 2g = -2
    · Betti numbers (b₀,b₁,b₂) = (1, 4, 1); alternating sum = -2
    · no full coverage: a nowhere-zero tangent field exists iff χ=0 — here χ = -2 ≠ 0
    · octagon [a,b][c,d]: 8 edges, 4 generators, one relation; vertex angle 2π/8 = 45°
    · Gauss–Bonnet: ∫K dA = 2πχ = -4π; hyperbolic area (K=−1) = 4π
    · moduli / Teichmüller dimension 6g − 6 = 6
  folded torus root: 59ebb830-ec50… — decidable topology, no full coverage.

the surface

src/the/surface/index.ts
the surface — the classification of all closed surfaces:

  complete invariant: (χ, orientability). coverage (nowhere-zero field) iff χ=0.

    surface                   χ    geometry    full coverage
    sphere S²                 2    spherical   no
    projective plane ℝP²      1    spherical   no
    torus T² (g=1)            0    flat        yes
    Klein bottle (k=2)        0    flat        yes
    double torus Σ₂ (g=2)     -2   hyperbolic  no
    genus-3 (g=3)             -4   hyperbolic  no

  only the torus and the Klein bottle can be fully covered. folded surface root: b9119021-91f6…
  decidable topology.

the abundance

src/the/abundance/index.ts
the abundance — money, milk, and honey (honestly):

  the money: the two coins = 110 − 108 = 2 = −χ(genus-2); the commercial fare
    reinvested in development — not extracted, not a promise of return.
  the honey: the honeycomb — among regular polygons only {3,4,6} tile the plane;
    the hexagon is optimal (honeycomb theorem, Hales 2001).
  the milk: the freely-given ledger — decidable facts, CC BY-NC; a copy costs nothing (non-rival).
  abundance is shared knowledge, not a fortune. folded root: 63afd2b1-5dd9…

the cancer

src/the/cancer/index.ts
the cancer — the epistemic anti-pattern (NOT the disease):

  NO medical claim is made here; a cure-claim DRAINS at the honesty gate.
  "cancer" = unchecked dishonest growth: an overclaim, a churn version, a receiptless claim.
  folding inverts it — the false form drains (death), its honest negation signs (resurrection):
    ✗ breaks encryption   →   ✓ does not break encryption — one-way integrity
    ✗ cured cancer   →   ✓ has not cured cancer — no medical claim
    ✗ breaks RSA   →   ✓ does not break RSA
  the traitor drains to death and rises as a hero — the honest form. it dissolves BY ITSELF,
  but the dissolution DEPENDS ON THE WAVES: every build re-verifies the whole ledger and re-runs
  the gate, so a false claim drains on every pass and cannot persist — more waves, surer healing,
  no waste unrecycled. folded root: 9388a5e7-0f14…

the waves

src/the/waves/index.ts
the waves — what directly affects the user’s state (honestly):

  devices emit real, measurable waves — screen light, sound, RF. this deposit makes NO health
  or harm claim about them; such claims drain at the gate. what it computes is the INFORMATION
  wave: the query / referrer / path you send → digital root (ℤ/9) → a432 hue (d·40°) → your view.

    wave         → digit → hue    | balancing wave: 9−d → hue    (sum → harmony)
    rock         →  8   →  320°   | 1 → 40°   (d+b=9, hues sum 0°)
    paper        →  5   →  200°   | 4 → 160°   (d+b=9, hues sum 0°)
    scissors     →  7   →  280°   | 2 → 80°   (d+b=9, hues sum 0°)
    ceccec       →  4   →  160°   | 5 → 200°   (d+b=9, hues sum 0°)

  the balancing wave 9−d harmonises: the two digits sum to 9 (the rest), their hues to 360°=0.
  same wave, same state; a different wave, a different point of view. deterministic.

the rosetta

src/the/rosetta/index.ts
the rosetta — completed (the star: every domain one hop from the core):

  core: df5571fb-0ae4…
  domains (59): z9-arithmetic · units-triad · doubling-orbit · inverses · powers · primes · cyclic-groups · boolean-algebra · entanglement · dialectic · games · arts · gematria · language-lens · merkle-ledger · harmonic-ledger · no-payload-security · involutions · fibonacci-cassini · lucas-pell · finite-fields · perfect-amicable · collatz · stirling · graph-coloring · rule90-sierpinski · continued-fractions · quaternions · motzkin · bernoulli · catalan · divisor-sums · platonic-solids · crystal-diamond · genus-topology · surfaces · wilson-fermat · figurate · rock-paper-scissors · self-similarity · fair-division · honeycomb · waves · forensics · ramsey · inequalities · partitions · lucas-theorem · pigeonhole · pick · cantor-pairing · chinese-remainder · quadratic-residues · path · abundance · cancer · superposition · creation-week · relations
  each reachable in one hop; 59 distinct addresses (no collision — complete)
  folded rosetta root 4d7b1c72-61de… — the cross-domain translation is complete.

the clown

src/the/clown/index.ts
the clown — benefits from all, respects the rules:

  juggles (a valid siteswap is a permutation; balls = average of digits):
    531   valid   3 balls
    441   valid   3 balls
    97531   valid   5 balls
    522   valid   3 balls
  navigates chaos (logistic r=4): two orbits 1e-9 apart spread to 0.422 in 50 steps.
  benefits from all: 59 domains, each one hop from the core (the rosetta).
  respects the rules: every play clears the honesty gate — freedom within the rules.
  folded clown root 851aa39e-7d44…

the game

src/the/game/index.ts
the game — games, arts and sciences meet in one:

  the game (games)       → e53b23e6-b94a…
  the art (arts)         → 58ba4b31-f815…
  the science (sciences) → fa83fbfa-75f3…
  the one root (order-independent): d83b75c4-c741…
  order does not matter — that symmetry is the harmony. all meet in one.

the heart

src/the/heart/index.ts
the heart — 5, the centre of ℤ/9:

  the middle digit of 1..9: 5
  on the doubling circuit: 1 → 2 → 4 → 8 → 7 → 5  (5 closes it back to 1)
  the pentagon (5 sides): diagonal / side = φ, the golden ratio
  the word "vortex" digital-roots to 5 — the centre names itself
  address: ef286e8c-a517…

from the heart

src/from/the/heart/index.ts
from the heart (5) — the generative act:

  next computes from the heart: discover a decidable fact → save it → prove it → ship it.
  each wave flows from the centre (5) along the circuit: 1 → 2 → 4 → 8 → 7 → 5.
  what is discovered is kept iff it computes; the rest is drained. from the heart, honestly.
  address: 499760d6-49f8…

play the game

src/play/the/game/index.ts
play the game — the act:

  play: run next → a wave discovers decidable facts → proves them → ships them.
  the games (Nim, Wythoff, chess, tic-tac-toe, …) and their receipts fold to one root.
  the rules: measure · gate · due process · receipts · one game — all playable, all honest.
  a move is kept iff it computes; an over-reach is drained with a case. play, honestly.
  address: 2c1ae2db-84fa…

All theorems — the ledger ​

Every decidable fact the deposit has discovered, rendered from src/proof/discovered.json — the complete ledger, re-verified by exhaustion on each build. None is a Clay Millennium result; all land on

Latest discoveries — the newest 8, newest first. This section updates itself every build, because it reads the ledger directly.

  1. lean planck.lean: the_relations_cannot_express_the_uncertainty_they_inherit — missPpb quantumLhs quantumRhs > missPpb gravityLhs gravityRhs ∧ missPpb gravityLhs gravityRhs * 1000 < ppm bigG bigGUnc * 1000000 ∧ gPpm dimMP = 11 ∧ gPpm (dmul dimEllP dimMP) = 0 — decided by the Lean kernel over its whole finite domain, axiom-free9e420848-d43d…
  2. lean planck.lean: length_over_mass_meets_gravity_in_the_digits — missPpb gravityLhs gravityRhs = 142 — decided by the Lean kernel over its whole finite domain, axiom-free9c98e0ea-4fdb…
  3. lean planck.lean: length_times_mass_meets_the_quantum_in_the_digits — missPpb quantumLhs quantumRhs = 171 — decided by the Lean kernel over its whole finite domain, axiom-free5da05fbd-34e5…
  4. lean light.lean: the_faraday_constant_is_an_exact_product_of_two_defined_constants — faraday = 964853321233100184 — decided by the Lean kernel over its whole finite domain, axiom-freece0f984b-550e…
  5. lean light.lean: the_molar_gas_constant_is_an_exact_product_of_two_defined_constants — molarGas = 831446261815324 — decided by the Lean kernel over its whole finite domain, axiom-free8b8f7b5c-e29c…
  6. lean handle.lean: an_address_never_determines_the_message_it_addresses — (List.range 16).all (fun a => 1 < ((List.range 64).filter (fun m => addr m == a)).length) — decided by the Lean kernel over its whole finite domain, axiom-free147d6591-a70a…
  7. lean handle.lean: reordering_the_handles_always_moves_the_fifth — (perms.map (fun p => fold4 (p.get! 0) (p.get! 1) (p.get! 2) (p.get! 3))).eraseDups.length = 24 — decided by the Lean kernel over its whole finite domain, axiom-free0509ef1a-9b13…
  8. lean handle.lean: the_same_message_at_two_positions_never_seals_alike — (List.range 32).all (fun m => (List.range 8).all (fun i => (List.range 8).all (fun j => i == j || sealAt m i != sealAt m j))) — decided by the Lean kernel over its whole finite domain, axiom-free606fefb8-c2ab…

969 live theorems — each verified in code and re-verified every build. Entries revoked in the append-only ledger are not listed.

  1. 1lean address.lean: raw_bytes_of_a — rawBytes A = [88, 118, 248, 251, 63, 149, 14, 202, 10, 251, 189, 97, 221, 134, 206, 204] — decided by the Lean kernel over its whole finite domain, axiom-free211de25d-e843…
  2. 2lean address.lean: to_uuid_bytes_of_a — toUuidBytes A = [88, 118, 248, 251, 63, 149, 142, 202, 138, 251, 189, 97, 221, 134, 206, 204] — decided by the Lean kernel over its whole finite domain, axiom-freec3f88cb7-dd38…
  3. 3lean address.lean: to_uuid_bytes_of_uuidna — toUuidBytes UUIDNA = [252, 81, 21, 50, 110, 138, 132, 24, 165, 34, 165, 27, 29, 70, 167, 12] — decided by the Lean kernel over its whole finite domain, axiom-free6a4f78d3-a979…
  4. 4lean address.lean: address_is_sixteen_bytes — (toUuidBytes UUIDNA).length = 16 — decided by the Lean kernel over its whole finite domain, axiom-freee8ffe03d-7ef1…
  5. 5lean address.lean: address_bytes_are_bytes — (toUuidBytes UUIDNA).all (fun b => b < 256) — decided by the Lean kernel over its whole finite domain, axiom-free3fc96e27-7831…
  6. 6lean address.lean: version_nibble_is_forced — ((toUuidBytes A).get! 6) / 16 = 8 ∧ ((toUuidBytes UUIDNA).get! 6) / 16 = 8 — decided by the Lean kernel over its whole finite domain, axiom-free47e811ae-f5e4…
  7. 7lean address.lean: variant_bits_are_forced — ((toUuidBytes A).get! 8) / 64 = 2 ∧ ((toUuidBytes UUIDNA).get! 8) / 64 = 2 — decided by the Lean kernel over its whole finite domain, axiom-free02c6e2b5-afb6…
  8. 8lean address.lean: addressing_is_deterministic — toUuidBytes A = toUuidBytes A — decided by the Lean kernel over its whole finite domain, axiom-freee62c309b-6bab…
  9. 9lean address.lean: distinct_seeds_give_distinct_addresses — toUuidBytes A ≠ toUuidBytes UUIDNA — decided by the Lean kernel over its whole finite domain, axiom-freed35a8b2c-29ad…
  10. 10lean address.lean: addressing_is_injective_on_single_characters — (((List.range 24).map (fun c => toUuidBytes [c])).eraseDups).length = 24 — decided by the Lean kernel over its whole finite domain, axiom-freea6887d02-4deb…
  11. 11lean address.lean: addressing_is_not_the_identity — toUuidBytes [7] ≠ [7] — decided by the Lean kernel over its whole finite domain, axiom-freed0637879-af00…
  12. 12lean address.lean: addressing_is_not_constant — toUuidBytes [1] ≠ toUuidBytes [2] — decided by the Lean kernel over its whole finite domain, axiom-free9c84b2cd-2a3a…
  13. 13lean address.lean: the_four_seeds_are_distinct — (SEEDS.eraseDups).length = 4 — decided by the Lean kernel over its whole finite domain, axiom-free1362d7ac-a87d…
  14. 14lean families.lean: flt_all_primes_under_thirty — primesUpTo30.all (fun p => (List.range' 1 (p - 1)).all (fun a => (a ^ (p - 1)) % p == 1)) — decided by the Lean kernel over its whole finite domain, axiom-freefbeecfea-5cbf…
  15. 15lean families.lean: wilson_all_primes_under_thirty — primesUpTo30.all (fun p => fact (p - 1) % p == p - 1) — decided by the Lean kernel over its whole finite domain, axiom-freedb3c3609-244e…
  16. 16lean families.lean: wilson_fails_at_composites — ((List.range' 4 20).filter (fun n => ! primesUpTo30.contains n)).all (fun n => fact (n - 1) % n != n - 1) — decided by the Lean kernel over its whole finite domain, axiom-freee9964842-9392…
  17. 17lean families.lean: pascal_rows_sum_to_powers_of_two — (List.range 12).all (fun n => ((List.range (n + 1)).map (fun k => choose n k)).foldl (· + ·) 0 == 2 ^ n) — decided by the Lean kernel over its whole finite domain, axiom-free92b5cdee-0ce0…
  18. 18lean families.lean: pascal_alternating_sums_vanish — (List.range' 1 11).all (fun n => ((List.range (n + 1)).map (fun k => if k % 2 == 0 then choose n k else 0)).foldl (· + ·) 0 == ((List.range (n + 1)).map (fun k => if k % 2 == 1 then choose n k else 0)).foldl (· + ·) 0) — decided by the Lean kernel over its whole finite domain, axiom-free521b9062-dba3…
  19. 19lean families.lean: totient_at_prime_powers — [2, 3, 5, 7].all (fun p => (List.range' 1 3).all (fun k => totient (p ^ k) == p ^ k - p ^ (k - 1))) — decided by the Lean kernel over its whole finite domain, axiom-free034c0066-ef85…
  20. 20lean families.lean: geometric_series_all_bases — (List.range' 2 8).all (fun b => ((List.range 5).map (fun i => b ^ i)).foldl (· + ·) 0 * (b - 1) == b ^ 5 - 1) — decided by the Lean kernel over its whole finite domain, axiom-freea1a0d8de-3069…
  21. 21lean families.lean: xor_is_parity_up_to_eight_bits — (List.range' 1 8).all (fun k => (List.range (2 ^ k)).all (fun n => popcount n % 2 == (List.range k).foldl (fun acc i => (acc + ((n >>> i) % 2)) % 2) 0)) — decided by the Lean kernel over its whole finite domain, axiom-freec643bfcf-2a91…
  22. 22lean families.lean: nat_div_is_a_total_function_returning_zero_at_a_zero_divisor — (7 / 0) = 0 ∧ (0 / 0) = 0 ∧ (7 % 0) = 7 — decided by the Lean kernel over its whole finite domain, axiom-free99ffd597-6911…
  23. 23lean families.lean: division_identity_holds_across_the_range — (List.range 13).all (fun d => (12 / d) * d + (12 % d) == 12) — decided by the Lean kernel over its whole finite domain, axiom-free1101f928-77e3…
  24. 24lean families.lean: at_a_zero_divisor_the_identity_is_carried_by_the_remainder — (12 / 0) = 0 ∧ (12 % 0) = 12 ∧ (12 / 0) * 0 + (12 % 0) == 12 — decided by the Lean kernel over its whole finite domain, axiom-freefb105eb9-c500…
  25. 25lean fnv.lean: hash_a_seed_zero — hash32 0 [97] = 1484191995 — decided by the Lean kernel over its whole finite domain, axiom-free6217ca32-aa73…
  26. 26lean fnv.lean: hash_ab_seed_zero — hash32 0 [97, 98] = 2049961697 — decided by the Lean kernel over its whole finite domain, axiom-free488d0227-0d40…
  27. 27lean fnv.lean: hash_a_seed_golden — hash32 2654435769 [97] = 1066733258 — decided by the Lean kernel over its whole finite domain, axiom-free1a33880c-45f6…
  28. 28lean fnv.lean: hash_uuidna_seed_zero — hash32 0 [117, 117, 105, 100, 110, 97] = 4233172274 — decided by the Lean kernel over its whole finite domain, axiom-free171433dd-5f27…
  29. 29lean fnv.lean: hash_is_deterministic — (List.range 32).all (fun c => hash32 0 [c] == hash32 0 [c]) — decided by the Lean kernel over its whole finite domain, axiom-free6bb8e484-c440…
  30. 30lean fnv.lean: hash_is_injective_on_single_characters — (((List.range 64).map (fun c => hash32 0 [c])).eraseDups).length = 64 — decided by the Lean kernel over its whole finite domain, axiom-freec3f18ca2-78a4…
  31. 31lean fnv.lean: the_seed_separates — (List.range 16).all (fun c => hash32 0 [c] != hash32 2654435769 [c]) — decided by the Lean kernel over its whole finite domain, axiom-free34c9dd31-1c39…
  32. 32lean fnv.lean: hash_is_not_the_identity — hash32 0 [7] != 7 — decided by the Lean kernel over its whole finite domain, axiom-free34be52dc-c3a2…
  33. 33lean fnv.lean: hash_is_not_constant — hash32 0 [1] != hash32 0 [2] — decided by the Lean kernel over its whole finite domain, axiom-freed65e7c3e-8771…
  34. 34lean fnv.lean: hash_is_thirty_two_bit — (List.range 40).all (fun c => hash32 0 [c] < M32) — decided by the Lean kernel over its whole finite domain, axiom-free6adee6ac-01b5…
  35. 35lean generated.lean: powsum_zero_odd_exponents — [1, 3, 5, 7, 9, 11, 13, 15, 17].all (fun k => (([1,2,4,5,7,8].map (fun u => (u ^ k) % 9)).foldl (· + ·) 0) % 9 == 0) — decided by the Lean kernel over its whole finite domain, axiom-freece4748ab-7b90…
  36. 36lean generated.lean: powsum_nonzero_at_even_exponents — ¬ ([2, 4, 6].all (fun k => (([1,2,4,5,7,8].map (fun u => (u ^ k) % 9)).foldl (· + ·) 0) % 9 == 0)) — decided by the Lean kernel over its whole finite domain, axiom-freeda7dc7ce-01ec…
  37. 37lean generated.lean: mulperm_iff_unit_all — (List.range 9).all (fun k => (((([1,2,4,5,7,8].map (fun u => (k * u) % 9)).eraseDups).length) == 6) == ([1,2,4,5,7,8].contains k)) — decided by the Lean kernel over its whole finite domain, axiom-free01a44bcc-6ae1…
  38. 38lean generated.lean: mulperm_fails_at_the_triad — ¬ ([3, 6, 0].any (fun k => ((([1,2,4,5,7,8].map (fun u => (k * u) % 9)).eraseDups).length) == 6)) — decided by the Lean kernel over its whole finite domain, axiom-free7f6f60f3-d775…
  39. 39lean generated.lean: addgen_iff_coprime_all — (List.range 9).all (fun k => ((((List.range 9).map (fun i => (k * i) % 9)).eraseDups).length == 9) == ([1,2,4,5,7,8].contains k)) — decided by the Lean kernel over its whole finite domain, axiom-freed23bb6f4-2735…
  40. 40lean generated.lean: hasinv_iff_unit_all — (List.range 9).all (fun d => ((List.range 9).any (fun e => (d * e) % 9 == 1)) == ([1,2,4,5,7,8].contains d)) — decided by the Lean kernel over its whole finite domain, axiom-free24020c39-2817…
  41. 41lean generated.lean: demorgan_all_widths — (List.range' 2 7).all (fun k => (List.range (2 ^ k)).all (fun n => (!((List.range k).all (fun i => (n >>> i) % 2 == 1))) == ((List.range k).any (fun i => (n >>> i) % 2 == 0)))) — decided by the Lean kernel over its whole finite domain, axiom-free45878828-7434…
  42. 42lean generated.lean: power_sum_closed_forms — (List.range' 1 30).all (fun n => (((List.range' 1 n).foldl (· + ·) 0) * 2 == n * (n + 1)) ∧ (((List.range' 1 n).map (fun i => i * i)).foldl (· + ·) 0) * 6 == n * (n + 1) * (2 * n + 1)) — decided by the Lean kernel over its whole finite domain, axiom-free4830f31e-7833…
  43. 43lean generated.lean: invpow_is_fifth_power_all_units — [1,2,4,5,7,8].all (fun u => (u * (u ^ 5)) % 9 == 1) — decided by the Lean kernel over its whole finite domain, axiom-free848e4a2c-b65a…
  44. 44lean generated.lean: invpow_fails_off_the_units — ¬ ([3, 6].any (fun t => (List.range 9).any (fun e => (t * e) % 9 == 1))) — decided by the Lean kernel over its whole finite domain, axiom-free9cd0abb7-c3dc…
  45. 45lean generated.lean: cyclic_units_have_a_primitive_root — [2,3,5,7,11,13].all (fun p => (List.range' 1 (p - 1)).any (fun g => (((List.range' 1 (p - 1)).map (fun k => (g ^ k) % p)).eraseDups).length == p - 1)) — decided by the Lean kernel over its whole finite domain, axiom-free21d5e557-5625…
  46. 46lean generated.lean: decimal_period_is_the_order_of_ten — [3,7,11,13,17,19,23,29].all (fun p => (List.range' 1 (p - 1)).any (fun k => (10 ^ k) % p == 1)) — decided by the Lean kernel over its whole finite domain, axiom-free85e474a6-76c3…
  47. 47lean generated.lean: primality_agrees_with_trial_division — (List.range' 2 40).all (fun n => ((List.range' 2 (n - 2)).all (fun d => n % d != 0)) == ([2,3,5,7,11,13,17,19,23,29,31,37,41].contains n)) — decided by the Lean kernel over its whole finite domain, axiom-free86e633b3-cc43…
  48. 48lean merkle.lean: merge_agrees — merge A B = [181, 59, 237, 190, 211, 88, 129, 103, 143, 231, 158, 123, 139, 178, 38, 2] — decided by the Lean kernel over its whole finite domain, axiom-free4298a48c-8e29…
  49. 49lean merkle.lean: empty_fold_agrees — merkleFold [] = [147, 146, 154, 45, 72, 16, 138, 198, 159, 50, 78, 208, 125, 158, 1, 108] — decided by the Lean kernel over its whole finite domain, axiom-freef96bc0ca-dac7…
  50. 50lean merkle.lean: singleton_fold_is_the_leaf — merkleFold [A] = A — decided by the Lean kernel over its whole finite domain, axiom-freea1f8cb03-417c…
  51. 51lean merkle.lean: pair_fold_agrees — merkleFold [A, B] = [181, 59, 237, 190, 211, 88, 129, 103, 143, 231, 158, 123, 139, 178, 38, 2] — decided by the Lean kernel over its whole finite domain, axiom-free7651bd48-d395…
  52. 52lean merkle.lean: fold_is_order_independent_on_two — merkleFold [A, B] = merkleFold [B, A] — decided by the Lean kernel over its whole finite domain, axiom-free26e3535b-82bd…
  53. 53lean merkle.lean: merge_is_order_sensitive — merge A B ≠ merge B A — decided by the Lean kernel over its whole finite domain, axiom-free3eda96b0-7e65…
  54. 54lean merkle.lean: sorting_is_what_makes_the_fold_order_free — sortB [A, B] = sortB [B, A] ∧ [A, B] ≠ [B, A] — decided by the Lean kernel over its whole finite domain, axiom-freefd6f4d99-6f2e…
  55. 55lean quantum.lean: perms_of_four_is_factorial — (perms [1, 2, 4, 8]).length = 24 — decided by the Lean kernel over its whole finite domain, axiom-free4fabbd78-28ba…
  56. 56lean quantum.lean: receipt_is_order_invariant — (perms [1, 2, 4, 8]).all (fun p => receipt p == receipt [1, 2, 4, 8]) — decided by the Lean kernel over its whole finite domain, axiom-free832611b4-9363…
  57. 57lean quantum.lean: receipt_order_invariant_on_the_orbit — (perms [1, 2, 4, 8, 7, 5]).all (fun p => receipt p == receipt [1, 2, 4, 8, 7, 5]) — decided by the Lean kernel over its whole finite domain, axiom-free6b255389-9fe6…
  58. 58lean quantum.lean: naive_fold_is_not_order_invariant — ¬ ((perms [1, 2, 4, 8]).all (fun p => naive p == naive [1, 2, 4, 8])) — decided by the Lean kernel over its whole finite domain, axiom-freeeb661483-6694…
  59. 59lean quantum.lean: superposition_collapses_to_one — ((perms [1, 2, 4, 8]).map receipt).eraseDups.length = 1 — decided by the Lean kernel over its whole finite domain, axiom-freec2ab5a2f-9fd5…
  60. 60lean reversal.lean: reversal_preserves_digit_sum — (List.range' 1 300).all (fun n => digitSum (reverseNum n) == digitSum n) — decided by the Lean kernel over its whole finite domain, axiom-freedb894765-359f…
  61. 61lean reversal.lean: digital_root_is_invariant_under_reversal — (List.range' 1 300).all (fun n => (reverseNum n) % 9 == n % 9) — decided by the Lean kernel over its whole finite domain, axiom-free352d594d-dd9a…
  62. 62lean reversal.lean: the_ledger_reversal_cases — (reverseNum 12) % 9 == 12 % 9 ∧ (reverseNum 45) % 9 == 45 % 9 ∧ (reverseNum 123) % 9 == 123 % 9 ∧ (reverseNum 1234) % 9 == 1234 % 9 ∧ (reverseNum 4321) % 9 == 4321 % 9 ∧ (reverseNum 9080) % 9 == 9080 % 9 — decided by the Lean kernel over its whole finite domain, axiom-free4bd3536b-805f…
  63. 63lean reversal.lean: reversal_is_not_the_identity — ¬ ((List.range' 10 90).all (fun n => reverseNum n == n)) — decided by the Lean kernel over its whole finite domain, axiom-free991f3d96-06d2…
  64. 64lean reversal.lean: palindromes_are_the_fixed_points — ((List.range' 10 90).filter (fun n => reverseNum n == n)).length = 9 — decided by the Lean kernel over its whole finite domain, axiom-free38c163fc-15bd…
  65. 65lean reversal.lean: emirps_exist_below_one_hundred — ((List.range' 10 90).filter (fun n => isPrime n && isPrime (reverseNum n) && reverseNum n != n)).length > 0 — decided by the Lean kernel over its whole finite domain, axiom-freeb9e6b77a-b12d…
  66. 66lean reversal.lean: reversal_does_not_preserve_primality — ¬ ((List.range' 10 90).all (fun n => isPrime n == isPrime (reverseNum n))) — decided by the Lean kernel over its whole finite domain, axiom-free3d5c8208-367c…
  67. 67lean theorems.lean: universal_reflection_involution — (List.range 11).all (fun d => refl (refl d) == d) -- σ ∘ σ = id everywhere — the shared involution ∧ ((List.range 10).filter (fun d => refl d == d)).length = 1 -- exactly ONE shared centre (the heart), computed — decided by the Lean kernel over its whole finite domain, axiom-free09141102-ade1…
  68. 68lean z9.lean: units_are_six — units = [1, 2, 4, 5, 7, 8] — decided by the Lean kernel over its whole finite domain, axiom-free76d332a5-ee8e…
  69. 69lean z9.lean: units_count — units.length = 6 — decided by the Lean kernel over its whole finite domain, axiom-free8b673ca0-cbd0…
  70. 70lean z9.lean: hasinv_units — units.all (fun u => (List.range B).any (fun e => m9 (u * e) == 1)) — decided by the Lean kernel over its whole finite domain, axiom-freec37ff607-4bbc…
  71. 71lean z9.lean: hasinv_triad_not — ¬ ([3, 6, 0].any (fun t => (List.range B).any (fun e => m9 (t * e) == 1))) — decided by the Lean kernel over its whole finite domain, axiom-free898e137c-9445…
  72. 72lean z9.lean: selfinv_exactly_one_and_eight — (units.filter (fun u => m9 (u * u) == 1)) = [1, 8] — decided by the Lean kernel over its whole finite domain, axiom-free7b3bc7e3-d34e…
  73. 73lean z9.lean: euler_units_pow_six — units.all (fun u => pow9 u 6 == 1) — decided by the Lean kernel over its whole finite domain, axiom-free1e4c6abe-a1c3…
  74. 74lean z9.lean: invpow_is_u_to_the_fifth — units.all (fun u => m9 (u * pow9 u 5) == 1) — decided by the Lean kernel over its whole finite domain, axiom-free480f158b-6a1e…
  75. 75lean z9.lean: powsum_zero_at_six — m9 ((units.map (fun u => pow9 u 6)).foldl (· + ·) 0) = 6 — decided by the Lean kernel over its whole finite domain, axiom-free9b3b882a-90d8…
  76. 76lean z9.lean: powsum_zero_at_one — m9 ((units.map (fun u => pow9 u 1)).foldl (· + ·) 0) = 0 — decided by the Lean kernel over its whole finite domain, axiom-freef5741c78-6ec5…
  77. 77lean z9.lean: mulperm_iff_unit — (List.range B).all (fun k => ((units.map (fun u => m9 (k * u))).eraseDups.length == units.length) == isUnit k) — decided by the Lean kernel over its whole finite domain, axiom-free37bbadd2-ef0c…
  78. 78lean z9.lean: addgen_iff_coprime — (List.range B).all (fun k => (((List.range B).map (fun i => m9 (k * i))).eraseDups.length == B) == isUnit k) — decided by the Lean kernel over its whole finite domain, axiom-freedfdf7fc0-4363…
  79. 79lean z9.lean: selfneg_only_zero — ((List.range B).filter (fun d => m9 (2 * d) == 0)) = [0] — decided by the Lean kernel over its whole finite domain, axiom-freeafe717ff-dd57…
  80. 80lean z9.lean: orbit_is_the_six — (List.range 6).map orbit = [1, 2, 4, 8, 7, 5] — decided by the Lean kernel over its whole finite domain, axiom-free71ca27b5-036d…
  81. 81lean z9.lean: orbit_closes — orbit 6 = orbit 0 — decided by the Lean kernel over its whole finite domain, axiom-freee49fb8ec-3651…
  82. 82lean z9.lean: orbit_distinct — ((List.range 6).map orbit).eraseDups.length = 6 — decided by the Lean kernel over its whole finite domain, axiom-freed373ad1a-9798…
  83. 83lean z9.lean: orbit_covers_units — ((List.range 6).map orbit).eraseDups.length = units.length — decided by the Lean kernel over its whole finite domain, axiom-free293a198a-6c28…
  84. 84lean z9.lean: triad_never_reaches_one — ¬ ((List.range 12).any (fun k => pow9 3 (k + 1) == 1 || pow9 6 (k + 1) == 1)) — decided by the Lean kernel over its whole finite domain, axiom-free20a9047b-0651…
  85. 85lean z9.lean: triad_squares_vanish — m9 (3 * 3) = 0 ∧ m9 (6 * 6) = 0 — decided by the Lean kernel over its whole finite domain, axiom-free5ce961f4-660b…
  86. 86lean z9.lean: add_group — (List.range B).all (fun d => (List.range B).any (fun e => m9 (d + e) == 0)) — decided by the Lean kernel over its whole finite domain, axiom-free312d6755-c2a1…
  87. 87lean z9.lean: neg_involution — (List.range B).all (fun d => m9 (B - m9 (B - d)) == m9 d) — decided by the Lean kernel over its whole finite domain, axiom-freee72bcc08-9e1e…
  88. 88lean nim.lean: bouton_two_heaps_lost_iff_xor_zero — (List.range N).all (fun a => (List.range N).all (fun b => isLost a b == (xorN a b == 0))) — decided by the Lean kernel over its whole finite domain, axiom-freed35edb15-4b67…
  89. 89lean nim.lean: bouton_lost_iff_heaps_equal — (List.range N).all (fun a => (List.range N).all (fun b => isLost a b == (a == b))) — decided by the Lean kernel over its whole finite domain, axiom-freec2f9d531-b836…
  90. 90lean nim.lean: lost_positions_are_exactly_the_diagonal — (((List.range N).flatMap (fun a => (List.range N).map (fun b => (a, b)))).filter (fun p => isLost p.1 p.2)).length = N — decided by the Lean kernel over its whole finite domain, axiom-free86e0163f-596b…
  91. 91lean nim.lean: grundy_of_a_single_heap_is_its_size — (List.range N).all (fun n => grundy1 (n + 1) n == n) — decided by the Lean kernel over its whole finite domain, axiom-freee08987d5-7608…
  92. 92lean nim.lean: grundy_of_two_heaps_is_the_xor — (List.range N).all (fun a => (List.range N).all (fun b => (xorN (grundy1 (a + 1) a) (grundy1 (b + 1) b)) == xorN a b)) — decided by the Lean kernel over its whole finite domain, axiom-free7ab70de7-b5fd…
  93. 93lean nim.lean: xor_is_its_own_inverse — (List.range 16).all (fun a => (List.range 16).all (fun b => xorN (xorN a b) b == a)) — decided by the Lean kernel over its whole finite domain, axiom-freef9930902-3aa3…
  94. 94lean nim.lean: xor_is_commutative — (List.range 16).all (fun a => (List.range 16).all (fun b => xorN a b == xorN b a)) — decided by the Lean kernel over its whole finite domain, axiom-free4be000e0-cf35…
  95. 95lean nim.lean: xor_zero_is_identity — (List.range 32).all (fun a => xorN a 0 == a) — decided by the Lean kernel over its whole finite domain, axiom-free59c8e95e-eaf1…
  96. 96lean z9plus.lean: squares_land_exactly_in_zero_one_four_seven — R.all (fun d => [0, 1, 4, 7].contains (m9 (d * d))) ∧ [0, 1, 4, 7].all (fun s => R.any (fun d => m9 (d * d) == s)) — decided by the Lean kernel over its whole finite domain, axiom-free0a46c7d9-795d…
  97. 97lean z9plus.lean: five_is_not_a_square_mod_nine — ¬ (R.any (fun d => m9 (d * d) == 5)) — decided by the Lean kernel over its whole finite domain, axiom-free20c33bf7-1bbe…
  98. 98lean z9plus.lean: cubes_land_exactly_in_zero_one_eight — R.all (fun d => [0, 1, 8].contains (pw d 3)) ∧ [0, 1, 8].all (fun c => R.any (fun d => pw d 3 == c)) — decided by the Lean kernel over its whole finite domain, axiom-freea0413156-e553…
  99. 99lean z9plus.lean: primitive_roots_are_exactly_two_and_five — (R.filter generates) = [2, 5] — decided by the Lean kernel over its whole finite domain, axiom-free8832fb36-edb0…
  100. 100lean z9plus.lean: primitive_root_iff_generates_the_units — R.all (fun g => generates g == ([2, 5].contains g)) — decided by the Lean kernel over its whole finite domain, axiom-free1d8d6e36-1984…
  101. 101lean z9plus.lean: doubling_has_period_six — (List.range 30).all (fun k => pw 2 k == pw 2 (k + 6)) — decided by the Lean kernel over its whole finite domain, axiom-free59e48172-1f6a…
  102. 102lean z9plus.lean: no_period_smaller_than_six — ¬ ([1, 2, 3, 4, 5].any (fun p => (List.range 12).all (fun k => pw 2 k == pw 2 (k + p)))) — decided by the Lean kernel over its whole finite domain, axiom-freee94365d4-1888…
  103. 103lean z9plus.lean: digital_root_agrees_with_the_residue — (List.range' 1 300).all (fun n => (dr n == 9) == (m9 n == 0)) — decided by the Lean kernel over its whole finite domain, axiom-free1696d96c-33a3…
  104. 104lean z9plus.lean: digital_root_is_the_digit_sum_residue — (List.range' 1 300).all (fun n => m9 (digitSum n) == m9 n) — decided by the Lean kernel over its whole finite domain, axiom-free14fd1431-bf05…
  105. 105lean z9plus.lean: reversal_cannot_change_the_digital_root — (List.range' 1 300).all (fun n => dr (reverseNum n) == dr n) — decided by the Lean kernel over its whole finite domain, axiom-free08720a64-6950…
  106. 106lean z9plus.lean: orbit_digital_roots_have_period_six — (List.range 24).all (fun k => dr (pw 2 k) == dr (pw 2 (k + 6))) — decided by the Lean kernel over its whole finite domain, axiom-free543f48a9-f482…
  107. 107lean z9plus.lean: units_and_triad_partition_the_ring — ((R.filter (fun d => R.any (fun e => m9 (d * e) == 1))).length + (R.filter (fun d => ! R.any (fun e => m9 (d * e) == 1))).length) = 9 — decided by the Lean kernel over its whole finite domain, axiom-free56d4fbda-6f25…
  108. 108lean z9plus.lean: both_parts_sum_to_zero — m9 ((R.filter (fun d => R.any (fun e => m9 (d * e) == 1))).foldl (· + ·) 0) == 0 ∧ m9 ((R.filter (fun d => ! R.any (fun e => m9 (d * e) == 1))).foldl (· + ·) 0) == 0 — decided by the Lean kernel over its whole finite domain, axiom-freeb30de9fd-1e1a…
  109. 109lean z9plus.lean: the_orders_of_the_units_are_exact — ord 1 = 1 ∧ ord 8 = 2 ∧ ord 4 = 3 ∧ ord 7 = 3 ∧ ord 2 = 6 ∧ ord 5 = 6 — decided by the Lean kernel over its whole finite domain, axiom-free48685f29-1bc3…
  110. 110lean z9plus.lean: the_unit_table_is_a_latin_square — [1,2,4,5,7,8].all (fun a => (([1,2,4,5,7,8].map (fun b => m9 (a * b))).eraseDups).length == 6 ∧ [1,2,4,5,7,8].all (fun c => [1,2,4,5,7,8].any (fun b => m9 (a * b) == c))) — decided by the Lean kernel over its whole finite domain, axiom-free1e106c4a-3816…
  111. 111lean z9plus.lean: the_orbit_never_meets_the_triad — (List.range 40).all (fun k => ! [0, 3, 6].contains (pw 2 k)) — decided by the Lean kernel over its whole finite domain, axiom-free38726843-73a6…
  112. 112lean z9plus.lean: the_reflected_orbit_covers_the_whole_triad — [3, 6, 9].all (fun t => orbit6.any (fun d => refl d == t)) — decided by the Lean kernel over its whole finite domain, axiom-free8c5d3165-37d8…
  113. 113lean z9plus.lean: reflection_splits_the_orbit_in_half — (orbit6.filter (fun d => [3, 6, 9].contains (refl d))).length = 3 ∧ (orbit6.filter (fun d => ! [3, 6, 9].contains (refl d))).length = 3 — decided by the Lean kernel over its whole finite domain, axiom-free2ee0d0dc-45d4…
  114. 114lean z9plus.lean: the_crossing_pairs_are_one_four_seven — (orbit6.filter (fun d => [3, 6, 9].contains (refl d))) = [1, 4, 7] ∧ refl 1 = 9 ∧ refl 4 = 6 ∧ refl 7 = 3 — decided by the Lean kernel over its whole finite domain, axiom-freefd5ff6f1-1655…
  115. 115lean z9plus.lean: reflection_is_injective_on_the_orbit — ((orbit6.map refl).eraseDups).length = 6 — decided by the Lean kernel over its whole finite domain, axiom-freee63ebd6e-bace…
  116. 116lean z9plus.lean: doubling_alone_reaches_only_the_units — ((List.range 12).map (fun k => pw 2 k)).eraseDups.length = 6 ∧ ((List.range 12).map (fun k => pw 2 k)).all (fun d => ! [0, 3, 6].contains d) — decided by the Lean kernel over its whole finite domain, axiom-free8fb1adf8-9b65…
  117. 117lean z9plus.lean: reflection_alone_reaches_only_two — (closure 6 [1]).length ≥ 2 ∧ rfl9 1 = 0 ∧ rfl9 (rfl9 1) = 1 — decided by the Lean kernel over its whole finite domain, axiom-freedd50d767-7566…
  118. 118lean z9plus.lean: doubling_and_reflection_together_reach_every_residue — (closure 4 [1]).length = 9 — decided by the Lean kernel over its whole finite domain, axiom-free5c55b180-d10e…
  119. 119lean z9plus.lean: every_residue_is_reachable_from_one — (List.range 9).all (fun d => (closure 4 [1]).contains d) — decided by the Lean kernel over its whole finite domain, axiom-freee7433a57-1934…
  120. 120lean z9plus.lean: the_diameter_is_exactly_four — (closure 4 [1]).length = 9 ∧ (closure 3 [1]).length = 7 — decided by the Lean kernel over its whole finite domain, axiom-free479589da-0e75…
  121. 121lean z9plus.lean: the_frontier_grows_by_two_each_round — (closure 0 [1]).length = 1 ∧ (closure 1 [1]).length = 3 ∧ (closure 2 [1]).length = 5 ∧ (closure 3 [1]).length = 7 ∧ (closure 4 [1]).length = 9 — decided by the Lean kernel over its whole finite domain, axiom-freeb338c80b-1898…
  122. 122lean z9plus.lean: product_of_the_units_is_minus_one — m9 ([1,2,4,5,7,8].foldl (· * ·) 1) = 8 ∧ m9 (8 + 1) = 0 — decided by the Lean kernel over its whole finite domain, axiom-freeb731fc18-fee2…
  123. 123lean z9plus.lean: pisano_period_mod_nine_is_twenty_four — (List.range 30).all (fun k => fib9 k == fib9 (k + 24)) — decided by the Lean kernel over its whole finite domain, axiom-free87f22860-4386…
  124. 124lean z9plus.lean: no_proper_divisor_of_twenty_four_is_a_period — ¬ ([1, 2, 3, 4, 6, 8, 12].any (fun p => (List.range 26).all (fun k => fib9 k == fib9 (k + p)))) — decided by the Lean kernel over its whole finite domain, axiom-free2ffb3f99-d850…
  125. 125lean z9plus.lean: fibonacci_recurrence_holds — (List.range 20).all (fun n => fib (n + 2) == fib n + fib (n + 1)) — decided by the Lean kernel over its whole finite domain, axiom-free2953f153-67e8…
  126. 126lean z9plus.lean: consecutive_fibonacci_are_coprime — (List.range' 1 15).all (fun n => gcd9 (fib n) (fib (n + 1)) == 1) — decided by the Lean kernel over its whole finite domain, axiom-freee8906360-31c5…
  127. 127lean z9plus.lean: three_five_eight_are_consecutive_fibonacci — fib 4 = 3 ∧ fib 5 = 5 ∧ fib 6 = 8 ∧ fib 4 + fib 5 = fib 6 — decided by the Lean kernel over its whole finite domain, axiom-free7575c9eb-fd7f…
  128. 128lean sequences.lean: cassini_at_even_indices — (List.range' 1 20).all (fun n => n % 2 == 1 || fib (n - 1) * fib (n + 1) == fib n * fib n + 1) — decided by the Lean kernel over its whole finite domain, axiom-freea618d9ae-8af7…
  129. 129lean sequences.lean: cassini_at_odd_indices — (List.range' 1 20).all (fun n => n % 2 == 0 || fib (n - 1) * fib (n + 1) + 1 == fib n * fib n) — decided by the Lean kernel over its whole finite domain, axiom-freeb42d7ae9-ec74…
  130. 130lean sequences.lean: cassini_deviation_is_exactly_one — (List.range' 1 20).all (fun n => (fib (n - 1) * fib (n + 1) == fib n * fib n + 1) || (fib (n - 1) * fib (n + 1) + 1 == fib n * fib n)) — decided by the Lean kernel over its whole finite domain, axiom-free8563fd0c-91ef…
  131. 131lean sequences.lean: lucas_mod_two_is_the_and_rule — (List.range 14).all (fun n => (List.range (n + 1)).all (fun k => (choose n k % 2 == 1) == (andN k n == k))) — decided by the Lean kernel over its whole finite domain, axiom-free2396c70a-73a7…
  132. 132lean sequences.lean: pascal_has_both_parities — ((List.range 14).flatMap (fun n => (List.range (n + 1)).map (fun k => choose n k % 2))).contains 1 ∧ ((List.range 14).flatMap (fun n => (List.range (n + 1)).map (fun k => choose n k % 2))).contains 0 — decided by the Lean kernel over its whole finite domain, axiom-freefc910b31-5054…
  133. 133lean sequences.lean: sums_of_two_squares_are_closed — (List.range 8).all (fun a => (List.range 8).all (fun b => (List.range 8).all (fun c => (List.range 8).all (fun d => (a*a + b*b) * (c*c + d*d) == (a*c - b*d) * (a*c - b*d) + (a*d + b*c) * (a*d + b*c) || (a*c) < (b*d))))) — decided by the Lean kernel over its whole finite domain, axiom-freefca198ef-9b8b…
  134. 134lean sequences.lean: three_five_eight_are_consecutive — fib 4 = 3 ∧ fib 5 = 5 ∧ fib 6 = 8 ∧ fib 4 + fib 5 = fib 6 — decided by the Lean kernel over its whole finite domain, axiom-free2c1fb60c-6564…
  135. 135lean sequences.lean: pisano_twentyfour_is_four_sixes — (List.range 30).all (fun k => fib k % 9 == fib (k + 24) % 9) ∧ 24 = 4 * 6 — decided by the Lean kernel over its whole finite domain, axiom-free780bfeec-e476…
  136. 136lean mechanical.lean: add_group — (List.range' 1 9).all (fun d => (List.range' 1 9).any (fun e => M9 (d + e) == 0)) — decided by the Lean kernel over its whole finite domain, axiom-free0bf99a9b-8d78…
  137. 137lean mechanical.lean: merkaba_cube_q3 — 2 ^ 3 == 8 && 3 * 2 ^ 2 == 12 — decided by the Lean kernel over its whole finite domain, axiom-free6963c8ac-e3e6…
  138. 138lean mechanical.lean: trial_zero_no_inverse — !(List.range' 1 9).any (fun e => M9 (0 * e) == 1) — decided by the Lean kernel over its whole finite domain, axiom-freef336fdf5-76ee…
  139. 139lean mechanical.lean: gf4_size — [0, 1, 2, 3].length == 2 ^ 2 — decided by the Lean kernel over its whole finite domain, axiom-freedaf893bd-dc5f…
  140. 140lean mechanical.lean: harmonic_pythagorean_comma — 3 ^ 12 == 531441 && 2 ^ 19 == 524288 && 3 ^ 12 != 2 ^ 19 — decided by the Lean kernel over its whole finite domain, axiom-freeeb59929b-c67e…
  141. 141lean mechanical.lean: relation_eight — 2 ^ 3 == 8 && 8 * 8 == 64 — decided by the Lean kernel over its whole finite domain, axiom-freea39da385-334c…
  142. 142lean mechanical.lean: relation_seven_is_six_plus_one — [1,2,4,5,7,8].length == 6 && 6 + 1 == 7 && 7 - 1 == 6 — decided by the Lean kernel over its whole finite domain, axiom-free4cc8e257-5368…
  143. 143lean mechanical.lean: the_cyclic_number_142857_is_the_repetend_of_one_seventh — 999999 % 7 == 0 && 999999 / 7 == 142857 — decided by the Lean kernel over its whole finite domain, axiom-free84678499-42cd…
  144. 144lean mechanical.lean: the_digital_root_of_seven_to_the_k_has_period_three — 7 ^ 1 % 9 == 7 && 7 ^ 2 % 9 == 4 && 7 ^ 3 % 9 == 1 && 7 ^ 4 % 9 == 7 — decided by the Lean kernel over its whole finite domain, axiom-free35da1bae-5b79…
  145. 145lean mechanical.lean: seven_divides_the_repunit_of_length_six — 111111 % 7 == 0 — decided by the Lean kernel over its whole finite domain, axiom-free5de46f3e-a628…
  146. 146lean mechanical.lean: two_to_the_eighth_is_two_hundred_fifty_six_a_byte — 2 ^ 8 == 256 — decided by the Lean kernel over its whole finite domain, axiom-free34caada8-dd09…
  147. 147lean mechanical.lean: two_to_the_tenth_is_1024_the_harmonic_ledger — 2 ^ 10 == 1024 — decided by the Lean kernel over its whole finite domain, axiom-free04218536-2a34…
  148. 148lean mechanical.lean: nine_is_the_base_and_the_trinity_squared — 9 == 9 && 9 == 3 ^ 2 && 3 == 3 — decided by the Lean kernel over its whole finite domain, axiom-freef0b0a052-058c…
  149. 149lean mechanical.lean: five_is_the_inverse_of_two_so_halving_reverses_the_orbit — (2 * 5) % 9 == 1 — decided by the Lean kernel over its whole finite domain, axiom-free32ceaab8-afe0…
  150. 150lean mechanical.lean: dna_is_the_version_itself — 4 ^ 3 == 64 — decided by the Lean kernel over its whole finite domain, axiom-free1527985d-54ef…
  151. 151lean mechanical.lean: genetic_code_is_the_octave_squared — 4 ^ 3 == 64 && 64 == 8 * 8 && 64 % 8 == 0 — decided by the Lean kernel over its whole finite domain, axiom-freea4bd830f-54a6…
  152. 152lean mechanical.lean: genesis_1_the_unit — [1, 2, 3, 4, 5, 6, 7, 8, 9].all (fun n => 1 * n == n) && 1 ^ 7 == 1 — decided by the Lean kernel over its whole finite domain, axiom-freeb5cc42a3-c620…
  153. 153lean mechanical.lean: genesis_8_the_octave — 2 ^ 3 == 8 && 8 % 8 == 0 && 8 == 2 * 2 * 2 — decided by the Lean kernel over its whole finite domain, axiom-free3484a89d-0551…
  154. 154lean mechanical.lean: genesis_64_the_codon — 4 ^ 3 == 64 && 2 ^ 6 == 64 && 8 ^ 2 == 64 — decided by the Lean kernel over its whole finite domain, axiom-free5bc3c52a-0484…
  155. 155lean mechanical.lean: a432_factors_as_two_to_the_fourth_times_three_cubed — 2 ^ 4 * 3 ^ 3 == 432 && 16 * 27 == 432 — decided by the Lean kernel over its whole finite domain, axiom-freeace5e026-76f2…
  156. 156lean mechanical.lean: two_bits_thrice_make_the_codon — 2 ^ 6 == 64 && (2 ^ 2) ^ 3 == 64 && 4 ^ 3 == 64 — decided by the Lean kernel over its whole finite domain, axiom-freed7a6008c-4238…
  157. 157lean mechanical.lean: the_full_superposition_has_nine_states — (List.range' 1 9).length == 9 — decided by the Lean kernel over its whole finite domain, axiom-freefcdb464a-6436…
  158. 158lean mechanical.lean: trial_units_group — let U9 := [1,2,4,5,7,8]; U9.all (fun u => U9.all (fun v => U9.contains (M9 (u * v)))) && U9.contains (1) && U9.all (fun u => U9.any (fun w => M9 (u * w) == 1)) — decided by the Lean kernel over its whole finite domain, axiom-free15329fd6-4630…
  159. 159lean mechanical.lean: genus2_h1_symplectic — let rank := 2 * 2; rank == 4 && rank % 2 == 0 — decided by the Lean kernel over its whole finite domain, axiom-freed8a36344-ce56…
  160. 160lean ledgerclaims.lean: a_seal_is_128_bits — (toUuidBytes [97]).length * 8 = 128 — decided by the Lean kernel over its whole finite domain, axiom-freec552c1db-5200…
  161. 161lean ledgerclaims.lean: membership_grows_by_one_seal_per_doubling — rounds 40 2 = 1 ∧ rounds 40 4 = 2 ∧ rounds 40 8 = 3 ∧ rounds 40 16 = 4 ∧ rounds 40 32 = 5 ∧ rounds 40 64 = 6 ∧ rounds 40 128 = 7 ∧ rounds 40 256 = 8 — decided by the Lean kernel over its whole finite domain, axiom-free0f753f22-7a7e…
  162. 162lean ledgerclaims.lean: membership_is_logarithmic_not_linear — rounds 40 1024 = 10 ∧ rounds 40 1024 < 1024 ∧ rounds 40 1024 * 128 < 1024 * 128 — decided by the Lean kernel over its whole finite domain, axiom-freec45f3e11-aa53…
  163. 163lean ledgerclaims.lean: the_967_receipt_case — saving 967 20 = 947 ∧ 20 + 947 = 967 — decided by the Lean kernel over its whole finite domain, axiom-free94cd508a-bbf3…
  164. 164lean ledgerclaims.lean: a_saving_never_exceeds_its_value — (List.range 40).all (fun v => (List.range 40).all (fun w => saving v w ≤ v)) — decided by the Lean kernel over its whole finite domain, axiom-freec6d64f4f-b2d8…
  165. 165lean ledgerclaims.lean: more_payloads_than_addresses_must_collide — ((List.range 17).map addr4).eraseDups.length < 17 — decided by the Lean kernel over its whole finite domain, axiom-free83447fc9-2e89…
  166. 166lean ledgerclaims.lean: the_address_does_not_determine_the_payload — ((List.range 17).any (fun a => (List.range 17).any (fun b => a != b && addr4 a == addr4 b))) = true — decided by the Lean kernel over its whole finite domain, axiom-free4dbd784f-cd12…
  167. 167lean ledgerclaims.lean: a_proof_is_smaller_than_its_set_across_the_octave — (List.range' 2 255).all (fun n => rounds 40 n < n) — decided by the Lean kernel over its whole finite domain, axiom-freebd52bf4d-20ac…
  168. 168lean merkle.lean: fold_is_order_independent_on_three — merkleFold [A, B, C] = merkleFold [A, C, B] ∧ merkleFold [A, B, C] = merkleFold [B, A, C] ∧ merkleFold [A, B, C] = merkleFold [B, C, A] ∧ merkleFold [A, B, C] = merkleFold [C, A, B] ∧ merkleFold [A, B, C] = merkleFold [C, B, A] — decided by the Lean kernel over its whole finite domain, axiom-freed127c5dd-11ea…
  169. 169lean quantum.lean: the_invariance_is_canonicalisation_not_physics — (perms [1, 2, 4, 8]).all (fun p => sort p == sort [1, 2, 4, 8]) — decided by the Lean kernel over its whole finite domain, axiom-free8fc67bd3-13d9…
  170. 170lean quantum.lean: the_receipt_is_not_injective — pairsOverNine.length = 45 ∧ (pairsOverNine.map receipt).eraseDups.length = 9 — decided by the Lean kernel over its whole finite domain, axiom-freee341b19b-3658…
  171. 171lean quantum.lean: the_uncanonicalised_fold_gives_many_answers — ((perms [1, 2, 4, 8]).map naive).eraseDups.length = 5 — decided by the Lean kernel over its whole finite domain, axiom-free35063521-90d0…
  172. 172lean reversal.lean: reversal_is_involutive_exactly_off_the_trailing_zeros — (List.range' 1 300).all (fun n => (reverseNum (reverseNum n) == n) == (n % 10 != 0)) — decided by the Lean kernel over its whole finite domain, axiom-free7c3f81f9-1ab8…
  173. 173lean fnv.lean: the_hash_is_order_sensitive — hash32 0 [97, 98] ≠ hash32 0 [98, 97] — decided by the Lean kernel over its whole finite domain, axiom-free9ebfd1f3-a326…
  174. 174lean fnv.lean: the_empty_input_is_still_mixed — hash32 0 [] = 2872998923 ∧ hash32 FNV_OFFSET [] = 0 ∧ avalanche 0 = 0 — decided by the Lean kernel over its whole finite domain, axiom-freea295a883-8e7e…
  175. 175lean index.lean: the_seven_rest_on_one_finite_structure — ((List.range' 1 9).all (fun d => refl (refl d) == d)) ∧ (((List.range' 1 9).filter isUnit).length = 6) ∧ (span.eraseDups.length = 6) ∧ provenHere = 0 — decided by the Lean kernel over its whole finite domain, axiom-freec4430b4b-f081…
  176. 176lean merkaba.lean: the_three_classes_partition_z9 — axis.length = 3 ∧ tetA.length = 3 ∧ tetB.length = 3 ∧ (axis ++ tetA ++ tetB).eraseDups.length = 9 ∧ ((List.range 9).all (fun d => (axis ++ tetA ++ tetB).contains d)) — decided by the Lean kernel over its whole finite domain, axiom-free347bb6f8-bba6…
  177. 177lean merkaba.lean: the_axis_is_closed_under_doubling — (dbl axis).all (fun d => axis.contains d) — decided by the Lean kernel over its whole finite domain, axiom-free9de5030e-7ecd…
  178. 178lean merkaba.lean: doubling_counter_rotates_the_two_tetrahedra — (dbl tetA).eraseDups.length = 3 ∧ (dbl tetA).all (fun d => tetB.contains d) ∧ (dbl tetB).eraseDups.length = 3 ∧ (dbl tetB).all (fun d => tetA.contains d) — decided by the Lean kernel over its whole finite domain, axiom-freea409ff11-15ca…
  179. 179lean merkaba.lean: the_counter_rotation_has_period_two — (dbl (dbl tetA)).all (fun d => tetA.contains d) ∧ (dbl (dbl tetB)).all (fun d => tetB.contains d) — decided by the Lean kernel over its whole finite domain, axiom-free7261ab56-ed9b…
  180. 180lean merkaba.lean: the_tetrahedra_residue_sums_cancel — m9 (tetA.foldl (· + ·) 0) = 3 ∧ m9 (tetB.foldl (· + ·) 0) = 6 ∧ m9 (tetA.foldl (· + ·) 0 + tetB.foldl (· + ·) 0) = 0 — decided by the Lean kernel over its whole finite domain, axiom-free8e4fb3a9-f5aa…
  181. 181lean merkaba.lean: one_tetrahedron_covers_half_the_units — (units.filter (fun d => tetA.contains d)).length = 3 ∧ (units.filter (fun d => tetB.contains d)).length = 3 ∧ units.length = 6 — decided by the Lean kernel over its whole finite domain, axiom-freec5305e5f-2386…
  182. 182lean merkaba.lean: the_cube_and_the_tetrahedron_count_out — 2 ^ 3 = 8 ∧ 3 * 2 ^ 2 = 12 ∧ 4 + 4 - 6 = 2 — decided by the Lean kernel over its whole finite domain, axiom-free18accb6b-20e6…
  183. 183lean merkaba.lean: stacked_triangles_are_tetrahedral — (List.range' 1 40).all (fun n => sumTri n == n * (n + 1) * (n + 2) / 6) — decided by the Lean kernel over its whole finite domain, axiom-free4611383b-7ebe…
  184. 184lean imagined.lean: units_is_closed_under_double — [1, 2, 4, 5, 7, 8].all (fun d => [1, 2, 4, 5, 7, 8].contains (m9 (2 * d))) — decided by the Lean kernel over its whole finite domain, axiom-free74b1c18a-9944…
  185. 185lean imagined.lean: orbit_is_closed_under_double — [1, 2, 4, 8, 7, 5].all (fun d => [1, 2, 4, 8, 7, 5].contains (m9 (2 * d))) — decided by the Lean kernel over its whole finite domain, axiom-free43137a9a-a239…
  186. 186lean imagined.lean: all_is_closed_under_double — [0,1,2,3,4,5,6,7,8].all (fun d => [0,1,2,3,4,5,6,7,8].contains (m9 (2 * d))) — decided by the Lean kernel over its whole finite domain, axiom-freea484e31e-4061…
  187. 187lean imagined.lean: triad_is_closed_under_triple — [3, 6, 0].all (fun d => [3, 6, 0].contains (m9 (3 * d))) — decided by the Lean kernel over its whole finite domain, axiom-free8a09c26a-d00f…
  188. 188lean imagined.lean: all_is_closed_under_triple — [0,1,2,3,4,5,6,7,8].all (fun d => [0,1,2,3,4,5,6,7,8].contains (m9 (3 * d))) — decided by the Lean kernel over its whole finite domain, axiom-free6721ec81-d9dc…
  189. 189lean imagined.lean: triad_is_closed_under_negate — [3, 6, 0].all (fun d => [3, 6, 0].contains (m9 (9 - d))) — decided by the Lean kernel over its whole finite domain, axiom-free5866147f-e850…
  190. 190lean imagined.lean: orbit_is_closed_under_negate — [1, 2, 4, 8, 7, 5].all (fun d => [1, 2, 4, 8, 7, 5].contains (m9 (9 - d))) — decided by the Lean kernel over its whole finite domain, axiom-free2648891c-b6ac…
  191. 191lean imagined.lean: all_is_closed_under_negate — [0,1,2,3,4,5,6,7,8].all (fun d => [0,1,2,3,4,5,6,7,8].contains (m9 (9 - d))) — decided by the Lean kernel over its whole finite domain, axiom-free488239aa-b8c4…
  192. 192lean imagined.lean: units_is_closed_under_square — [1, 2, 4, 5, 7, 8].all (fun d => [1, 2, 4, 5, 7, 8].contains (m9 (d * d))) — decided by the Lean kernel over its whole finite domain, axiom-free6d29a3cd-f0c8…
  193. 193lean imagined.lean: orbit_is_closed_under_square — [1, 2, 4, 8, 7, 5].all (fun d => [1, 2, 4, 8, 7, 5].contains (m9 (d * d))) — decided by the Lean kernel over its whole finite domain, axiom-freea001d862-2860…
  194. 194lean imagined.lean: tetA_is_closed_under_square — [1, 4, 7].all (fun d => [1, 4, 7].contains (m9 (d * d))) — decided by the Lean kernel over its whole finite domain, axiom-free1af8a50e-a0f9…
  195. 195lean imagined.lean: all_is_closed_under_square — [0,1,2,3,4,5,6,7,8].all (fun d => [0,1,2,3,4,5,6,7,8].contains (m9 (d * d))) — decided by the Lean kernel over its whole finite domain, axiom-freeeb6c5699-9bf8…
  196. 196lean imagined.lean: units_is_closed_under_quintuple — [1, 2, 4, 5, 7, 8].all (fun d => [1, 2, 4, 5, 7, 8].contains (m9 (5 * d))) — decided by the Lean kernel over its whole finite domain, axiom-free23146a0e-4f1a…
  197. 197lean imagined.lean: triad_is_closed_under_quintuple — [3, 6, 0].all (fun d => [3, 6, 0].contains (m9 (5 * d))) — decided by the Lean kernel over its whole finite domain, axiom-free0c782557-1e79…
  198. 198lean imagined.lean: orbit_is_closed_under_quintuple — [1, 2, 4, 8, 7, 5].all (fun d => [1, 2, 4, 8, 7, 5].contains (m9 (5 * d))) — decided by the Lean kernel over its whole finite domain, axiom-free36f80355-f5c0…
  199. 199lean imagined.lean: all_is_closed_under_quintuple — [0,1,2,3,4,5,6,7,8].all (fun d => [0,1,2,3,4,5,6,7,8].contains (m9 (5 * d))) — decided by the Lean kernel over its whole finite domain, axiom-freedae19453-3390…
  200. 200lean imagined.lean: quadruple_is_involutive_on_triad — [3, 6, 0].all (fun d => (fun x => m9 (4 * x)) (m9 (4 * d)) == d) — decided by the Lean kernel over its whole finite domain, axiom-free4633b9bd-d5d5…
  201. 201lean imagined.lean: square_is_involutive_on_tetA — [1, 4, 7].all (fun d => (fun x => m9 (x * x)) (m9 (d * d)) == d) — decided by the Lean kernel over its whole finite domain, axiom-freee13716ed-0ac5…
  202. 202lean imagined.lean: quintuple_is_involutive_on_triad — [3, 6, 0].all (fun d => (fun x => m9 (5 * x)) (m9 (5 * d)) == d) — decided by the Lean kernel over its whole finite domain, axiom-free98dcf6c8-a85e…
  203. 203lean imagined.lean: double_carries_units_onto_orbit — [1, 2, 4, 5, 7, 8].all (fun d => [1, 2, 4, 8, 7, 5].contains (m9 (2 * d))) ∧ ([1, 2, 4, 5, 7, 8].map (fun d => m9 (2 * d))).eraseDups.length = 6 — decided by the Lean kernel over its whole finite domain, axiom-free9c9d13f8-a0b4…
  204. 204lean imagined.lean: double_carries_orbit_onto_units — [1, 2, 4, 8, 7, 5].all (fun d => [1, 2, 4, 5, 7, 8].contains (m9 (2 * d))) ∧ ([1, 2, 4, 8, 7, 5].map (fun d => m9 (2 * d))).eraseDups.length = 6 — decided by the Lean kernel over its whole finite domain, axiom-free1fe514e5-9af2…
  205. 205lean imagined.lean: triple_carries_all_onto_triad — [0,1,2,3,4,5,6,7,8].all (fun d => [3, 6, 0].contains (m9 (3 * d))) ∧ ([0,1,2,3,4,5,6,7,8].map (fun d => m9 (3 * d))).eraseDups.length = 3 — decided by the Lean kernel over its whole finite domain, axiom-free99968f56-31e3…
  206. 206lean imagined.lean: quadruple_carries_units_onto_orbit — [1, 2, 4, 5, 7, 8].all (fun d => [1, 2, 4, 8, 7, 5].contains (m9 (4 * d))) ∧ ([1, 2, 4, 5, 7, 8].map (fun d => m9 (4 * d))).eraseDups.length = 6 — decided by the Lean kernel over its whole finite domain, axiom-freed37065ab-bac3…
  207. 207lean imagined.lean: quadruple_carries_orbit_onto_units — [1, 2, 4, 8, 7, 5].all (fun d => [1, 2, 4, 5, 7, 8].contains (m9 (4 * d))) ∧ ([1, 2, 4, 8, 7, 5].map (fun d => m9 (4 * d))).eraseDups.length = 6 — decided by the Lean kernel over its whole finite domain, axiom-freea8560589-8c23…
  208. 208lean imagined.lean: negate_carries_orbit_onto_units — [1, 2, 4, 8, 7, 5].all (fun d => [1, 2, 4, 5, 7, 8].contains (m9 (9 - d))) ∧ ([1, 2, 4, 8, 7, 5].map (fun d => m9 (9 - d))).eraseDups.length = 6 — decided by the Lean kernel over its whole finite domain, axiom-free9785d5df-38fb…
  209. 209lean imagined.lean: negate_carries_tetA_onto_tetB — [1, 4, 7].all (fun d => [2, 5, 8].contains (m9 (9 - d))) ∧ ([1, 4, 7].map (fun d => m9 (9 - d))).eraseDups.length = 3 — decided by the Lean kernel over its whole finite domain, axiom-freecd1a8234-fa1f…
  210. 210lean imagined.lean: negate_carries_tetB_onto_tetA — [2, 5, 8].all (fun d => [1, 4, 7].contains (m9 (9 - d))) ∧ ([2, 5, 8].map (fun d => m9 (9 - d))).eraseDups.length = 3 — decided by the Lean kernel over its whole finite domain, axiom-free2d5f2887-07ff…
  211. 211lean imagined.lean: square_carries_units_onto_tetA — [1, 2, 4, 5, 7, 8].all (fun d => [1, 4, 7].contains (m9 (d * d))) ∧ ([1, 2, 4, 5, 7, 8].map (fun d => m9 (d * d))).eraseDups.length = 3 — decided by the Lean kernel over its whole finite domain, axiom-freef57e0f22-217a…
  212. 212lean imagined.lean: square_carries_orbit_onto_tetA — [1, 2, 4, 8, 7, 5].all (fun d => [1, 4, 7].contains (m9 (d * d))) ∧ ([1, 2, 4, 8, 7, 5].map (fun d => m9 (d * d))).eraseDups.length = 3 — decided by the Lean kernel over its whole finite domain, axiom-freefce1a3af-47fc…
  213. 213lean imagined.lean: square_carries_tetB_onto_tetA — [2, 5, 8].all (fun d => [1, 4, 7].contains (m9 (d * d))) ∧ ([2, 5, 8].map (fun d => m9 (d * d))).eraseDups.length = 3 — decided by the Lean kernel over its whole finite domain, axiom-freebebc2b15-1fa2…
  214. 214lean imagined.lean: quintuple_carries_units_onto_orbit — [1, 2, 4, 5, 7, 8].all (fun d => [1, 2, 4, 8, 7, 5].contains (m9 (5 * d))) ∧ ([1, 2, 4, 5, 7, 8].map (fun d => m9 (5 * d))).eraseDups.length = 6 — decided by the Lean kernel over its whole finite domain, axiom-freedadc55f1-9dd3…
  215. 215lean imagined.lean: quintuple_carries_orbit_onto_units — [1, 2, 4, 8, 7, 5].all (fun d => [1, 2, 4, 5, 7, 8].contains (m9 (5 * d))) ∧ ([1, 2, 4, 8, 7, 5].map (fun d => m9 (5 * d))).eraseDups.length = 6 — decided by the Lean kernel over its whole finite domain, axiom-free65c0d9be-2315…
  216. 216lean imagined.lean: quintuple_carries_tetA_onto_tetB — [1, 4, 7].all (fun d => [2, 5, 8].contains (m9 (5 * d))) ∧ ([1, 4, 7].map (fun d => m9 (5 * d))).eraseDups.length = 3 — decided by the Lean kernel over its whole finite domain, axiom-free083aec67-2d52…
  217. 217lean imagined.lean: quintuple_carries_tetB_onto_tetA — [2, 5, 8].all (fun d => [1, 4, 7].contains (m9 (5 * d))) ∧ ([2, 5, 8].map (fun d => m9 (5 * d))).eraseDups.length = 3 — decided by the Lean kernel over its whole finite domain, axiom-free20e8affd-97c5…
  218. 218lean imagined.lean: triple_collapses_triad_to_one_value — ([3, 6, 0].map (fun d => m9 (3 * d))).eraseDups.length = 1 — decided by the Lean kernel over its whole finite domain, axiom-freeb69711cf-680d…
  219. 219lean imagined.lean: triple_collapses_tetA_to_one_value — ([1, 4, 7].map (fun d => m9 (3 * d))).eraseDups.length = 1 — decided by the Lean kernel over its whole finite domain, axiom-free09f1a817-8fcf…
  220. 220lean imagined.lean: triple_collapses_tetB_to_one_value — ([2, 5, 8].map (fun d => m9 (3 * d))).eraseDups.length = 1 — decided by the Lean kernel over its whole finite domain, axiom-free56e120e9-368e…
  221. 221lean imagined.lean: cube_collapses_triad_to_one_value — ([3, 6, 0].map (fun d => m9 (d * d * d))).eraseDups.length = 1 — decided by the Lean kernel over its whole finite domain, axiom-free1878b27c-8b5d…
  222. 222lean imagined.lean: cube_collapses_tetA_to_one_value — ([1, 4, 7].map (fun d => m9 (d * d * d))).eraseDups.length = 1 — decided by the Lean kernel over its whole finite domain, axiom-free89b479b2-bb01…
  223. 223lean imagined.lean: cube_collapses_tetB_to_one_value — ([2, 5, 8].map (fun d => m9 (d * d * d))).eraseDups.length = 1 — decided by the Lean kernel over its whole finite domain, axiom-freef0c171ba-5dd3…
  224. 224lean imagined.lean: triad_is_closed_under_sextuple — [3, 6, 0].all (fun d => [3, 6, 0].contains (m9 (6 * d))) — decided by the Lean kernel over its whole finite domain, axiom-freec6a3004b-4600…
  225. 225lean imagined.lean: all_is_closed_under_sextuple — [0,1,2,3,4,5,6,7,8].all (fun d => [0,1,2,3,4,5,6,7,8].contains (m9 (6 * d))) — decided by the Lean kernel over its whole finite domain, axiom-free487c1f28-9559…
  226. 226lean imagined.lean: units_is_closed_under_octuple — [1, 2, 4, 5, 7, 8].all (fun d => [1, 2, 4, 5, 7, 8].contains (m9 (8 * d))) — decided by the Lean kernel over its whole finite domain, axiom-freea7229156-86a5…
  227. 227lean imagined.lean: triad_is_closed_under_octuple — [3, 6, 0].all (fun d => [3, 6, 0].contains (m9 (8 * d))) — decided by the Lean kernel over its whole finite domain, axiom-free03033716-02a9…
  228. 228lean imagined.lean: orbit_is_closed_under_octuple — [1, 2, 4, 8, 7, 5].all (fun d => [1, 2, 4, 8, 7, 5].contains (m9 (8 * d))) — decided by the Lean kernel over its whole finite domain, axiom-free4f278f65-1bde…
  229. 229lean imagined.lean: all_is_closed_under_octuple — [0,1,2,3,4,5,6,7,8].all (fun d => [0,1,2,3,4,5,6,7,8].contains (m9 (8 * d))) — decided by the Lean kernel over its whole finite domain, axiom-free9188cd9f-002a…
  230. 230lean imagined.lean: septuple_is_involutive_on_triad — [3, 6, 0].all (fun d => (fun x => m9 (7 * x)) (m9 (7 * d)) == d) — decided by the Lean kernel over its whole finite domain, axiom-free172d9674-4d63…
  231. 231lean imagined.lean: sextuple_carries_all_onto_triad — [0,1,2,3,4,5,6,7,8].all (fun d => [3, 6, 0].contains (m9 (6 * d))) ∧ ([0,1,2,3,4,5,6,7,8].map (fun d => m9 (6 * d))).eraseDups.length = 3 — decided by the Lean kernel over its whole finite domain, axiom-free626b20bb-2221…
  232. 232lean imagined.lean: septuple_carries_units_onto_orbit — [1, 2, 4, 5, 7, 8].all (fun d => [1, 2, 4, 8, 7, 5].contains (m9 (7 * d))) ∧ ([1, 2, 4, 5, 7, 8].map (fun d => m9 (7 * d))).eraseDups.length = 6 — decided by the Lean kernel over its whole finite domain, axiom-freea8f55b84-94b6…
  233. 233lean imagined.lean: septuple_carries_orbit_onto_units — [1, 2, 4, 8, 7, 5].all (fun d => [1, 2, 4, 5, 7, 8].contains (m9 (7 * d))) ∧ ([1, 2, 4, 8, 7, 5].map (fun d => m9 (7 * d))).eraseDups.length = 6 — decided by the Lean kernel over its whole finite domain, axiom-free8df83d0f-2bed…
  234. 234lean imagined.lean: octuple_carries_units_onto_orbit — [1, 2, 4, 5, 7, 8].all (fun d => [1, 2, 4, 8, 7, 5].contains (m9 (8 * d))) ∧ ([1, 2, 4, 5, 7, 8].map (fun d => m9 (8 * d))).eraseDups.length = 6 — decided by the Lean kernel over its whole finite domain, axiom-freecee59fa8-fb75…
  235. 235lean imagined.lean: octuple_carries_orbit_onto_units — [1, 2, 4, 8, 7, 5].all (fun d => [1, 2, 4, 5, 7, 8].contains (m9 (8 * d))) ∧ ([1, 2, 4, 8, 7, 5].map (fun d => m9 (8 * d))).eraseDups.length = 6 — decided by the Lean kernel over its whole finite domain, axiom-freed133706e-bd8c…
  236. 236lean imagined.lean: octuple_carries_tetA_onto_tetB — [1, 4, 7].all (fun d => [2, 5, 8].contains (m9 (8 * d))) ∧ ([1, 4, 7].map (fun d => m9 (8 * d))).eraseDups.length = 3 — decided by the Lean kernel over its whole finite domain, axiom-freedfecc1ef-d81b…
  237. 237lean imagined.lean: octuple_carries_tetB_onto_tetA — [2, 5, 8].all (fun d => [1, 4, 7].contains (m9 (8 * d))) ∧ ([2, 5, 8].map (fun d => m9 (8 * d))).eraseDups.length = 3 — decided by the Lean kernel over its whole finite domain, axiom-free74ad9bcf-f22c…
  238. 238lean imagined.lean: sextuple_collapses_triad_to_one_value — ([3, 6, 0].map (fun d => m9 (6 * d))).eraseDups.length = 1 — decided by the Lean kernel over its whole finite domain, axiom-free6c5bf198-bd89…
  239. 239lean imagined.lean: sextuple_collapses_tetA_to_one_value — ([1, 4, 7].map (fun d => m9 (6 * d))).eraseDups.length = 1 — decided by the Lean kernel over its whole finite domain, axiom-freed29da6cf-62b5…
  240. 240lean imagined.lean: sextuple_collapses_tetB_to_one_value — ([2, 5, 8].map (fun d => m9 (6 * d))).eraseDups.length = 1 — decided by the Lean kernel over its whole finite domain, axiom-freeee2a3939-17c8…
  241. 241lean energy.lean: a_chain_of_efficiencies_can_only_lose — (List.range 101).all (fun a => (List.range 101).all (fun b => a * b ≤ 100 * a && a * b ≤ 100 * b)) — decided by the Lean kernel over its whole finite domain, axiom-free34cbdadb-77a7…
  242. 242lean energy.lean: the_gases_are_two_to_one_and_consume_each_other_exactly — 2 * 1 = 2 ∧ (2 * 100 / 3 = 66) ∧ (1 * 100 / 3 = 33) ∧ ¬ (1 * 1 = 2) — decided by the Lean kernel over its whole finite domain, axiom-free4411df61-18c7…
  243. 243lean energy.lean: mass_is_conserved_at_every_scale_so_the_loop_cannot_make_water — (List.range' 1 100).all (fun n => 2 * n * mgH2O == 2 * n * mgH2 + n * mgO2) ∧ ¬ ((List.range' 1 100).all (fun n => n * mgH2O == n * mgH2 + n * mgO2)) — decided by the Lean kernel over its whole finite domain, axiom-free55429cd8-2b19…
  244. 244lean energy.lean: one_litre_split_returns_one_litre_burnt — 111900 + 888100 = 1000000 ∧ 888100 * 100 / 111900 = 793 — decided by the Lean kernel over its whole finite domain, axiom-freee88c70d6-0123…
  245. 245lean energy.lean: only_oxy_hydrogen_burns_without_admitting_nitrogen — 7808 * 100 / 2095 = 372 ∧ 0 * 372 = 0 ∧ ¬ (372 = 0) — decided by the Lean kernel over its whole finite domain, axiom-free69997ab3-1d7e…
  246. 246lean energy.lean: the_two_to_one_is_forced_by_the_oxygen — balances 2 2 1 = true ∧ balances 1 1 1 = false ∧ (((List.range' 1 9).flatMap (fun a => (List.range' 1 9).flatMap (fun b => (List.range' 1 9).filter (fun c => balances a b c)))).length = 4) ∧ balances 4 4 2 = true ∧ balances 6 6 3 = true ∧ b… — decided by the Lean kernel over its whole finite domain, axiom-free75828bd9-1d34…
  247. 247lean imagined.lean: units_is_closed_under_quadruple — [1, 2, 4, 5, 7, 8].all (fun d => [1, 2, 4, 5, 7, 8].contains (m9 (4 * d))) — decided by the Lean kernel over its whole finite domain, axiom-freee90978b5-a350…
  248. 248lean imagined.lean: triad_is_closed_under_quadruple — [3, 6, 0].all (fun d => [3, 6, 0].contains (m9 (4 * d))) — decided by the Lean kernel over its whole finite domain, axiom-free6d2f140d-6eff…
  249. 249lean imagined.lean: orbit_is_closed_under_quadruple — [1, 2, 4, 8, 7, 5].all (fun d => [1, 2, 4, 8, 7, 5].contains (m9 (4 * d))) — decided by the Lean kernel over its whole finite domain, axiom-freef889d728-465d…
  250. 250lean imagined.lean: tetA_is_closed_under_quadruple — [1, 4, 7].all (fun d => [1, 4, 7].contains (m9 (4 * d))) — decided by the Lean kernel over its whole finite domain, axiom-freef9075b8c-6548…
  251. 251lean imagined.lean: tetB_is_closed_under_quadruple — [2, 5, 8].all (fun d => [2, 5, 8].contains (m9 (4 * d))) — decided by the Lean kernel over its whole finite domain, axiom-freed15e7f2a-be1e…
  252. 252lean imagined.lean: all_is_closed_under_quadruple — [0,1,2,3,4,5,6,7,8].all (fun d => [0,1,2,3,4,5,6,7,8].contains (m9 (4 * d))) — decided by the Lean kernel over its whole finite domain, axiom-free9fdde539-0c75…
  253. 253lean imagined.lean: squares_is_closed_under_quadruple — [0, 1, 4, 7].all (fun d => [0, 1, 4, 7].contains (m9 (4 * d))) — decided by the Lean kernel over its whole finite domain, axiom-free12d7a596-c1f8…
  254. 254lean imagined.lean: cubes_is_closed_under_negate — [0, 1, 8].all (fun d => [0, 1, 8].contains (m9 (9 - d))) — decided by the Lean kernel over its whole finite domain, axiom-free78ef83db-c595…
  255. 255lean imagined.lean: squares_is_closed_under_square — [0, 1, 4, 7].all (fun d => [0, 1, 4, 7].contains (m9 (d * d))) — decided by the Lean kernel over its whole finite domain, axiom-freebe288202-61e8…
  256. 256lean imagined.lean: cubes_is_closed_under_square — [0, 1, 8].all (fun d => [0, 1, 8].contains (m9 (d * d))) — decided by the Lean kernel over its whole finite domain, axiom-free827d987b-f6c7…
  257. 257lean imagined.lean: units_is_closed_under_septuple — [1, 2, 4, 5, 7, 8].all (fun d => [1, 2, 4, 5, 7, 8].contains (m9 (7 * d))) — decided by the Lean kernel over its whole finite domain, axiom-free33c6b2af-ea05…
  258. 258lean imagined.lean: triad_is_closed_under_septuple — [3, 6, 0].all (fun d => [3, 6, 0].contains (m9 (7 * d))) — decided by the Lean kernel over its whole finite domain, axiom-free64ea3fd6-5235…
  259. 259lean imagined.lean: orbit_is_closed_under_septuple — [1, 2, 4, 8, 7, 5].all (fun d => [1, 2, 4, 8, 7, 5].contains (m9 (7 * d))) — decided by the Lean kernel over its whole finite domain, axiom-free7a790873-2c87…
  260. 260lean imagined.lean: tetA_is_closed_under_septuple — [1, 4, 7].all (fun d => [1, 4, 7].contains (m9 (7 * d))) — decided by the Lean kernel over its whole finite domain, axiom-freed0845a96-1990…
  261. 261lean imagined.lean: tetB_is_closed_under_septuple — [2, 5, 8].all (fun d => [2, 5, 8].contains (m9 (7 * d))) — decided by the Lean kernel over its whole finite domain, axiom-free94ca3492-fc0f…
  262. 262lean imagined.lean: all_is_closed_under_septuple — [0,1,2,3,4,5,6,7,8].all (fun d => [0,1,2,3,4,5,6,7,8].contains (m9 (7 * d))) — decided by the Lean kernel over its whole finite domain, axiom-free360040f3-1afb…
  263. 263lean imagined.lean: squares_is_closed_under_septuple — [0, 1, 4, 7].all (fun d => [0, 1, 4, 7].contains (m9 (7 * d))) — decided by the Lean kernel over its whole finite domain, axiom-free929df56e-f860…
  264. 264lean imagined.lean: cubes_is_closed_under_octuple — [0, 1, 8].all (fun d => [0, 1, 8].contains (m9 (8 * d))) — decided by the Lean kernel over its whole finite domain, axiom-free91dcd0db-2571…
  265. 265lean imagined.lean: square_is_involutive_on_squares — [0, 1, 4, 7].all (fun d => (fun x => m9 (x * x)) (m9 (d * d)) == d) — decided by the Lean kernel over its whole finite domain, axiom-freeb71b08a8-b238…
  266. 266lean imagined.lean: cube_is_involutive_on_cubes — [0, 1, 8].all (fun d => (fun x => m9 (x * x * x)) (m9 (d * d * d)) == d) — decided by the Lean kernel over its whole finite domain, axiom-freed607231e-ecb2…
  267. 267lean imagined.lean: triple_carries_cubes_onto_triad — [0, 1, 8].all (fun d => [3, 6, 0].contains (m9 (3 * d))) ∧ ([0, 1, 8].map (fun d => m9 (3 * d))).eraseDups.length = 3 — decided by the Lean kernel over its whole finite domain, axiom-free07183390-0375…
  268. 268lean imagined.lean: square_carries_all_onto_squares — [0,1,2,3,4,5,6,7,8].all (fun d => [0, 1, 4, 7].contains (m9 (d * d))) ∧ ([0,1,2,3,4,5,6,7,8].map (fun d => m9 (d * d))).eraseDups.length = 4 — decided by the Lean kernel over its whole finite domain, axiom-free95bfa2f5-30af…
  269. 269lean imagined.lean: cube_carries_all_onto_cubes — [0,1,2,3,4,5,6,7,8].all (fun d => [0, 1, 8].contains (m9 (d * d * d))) ∧ ([0,1,2,3,4,5,6,7,8].map (fun d => m9 (d * d * d))).eraseDups.length = 3 — decided by the Lean kernel over its whole finite domain, axiom-free614b5517-fe8e…
  270. 270lean imagined.lean: sextuple_carries_cubes_onto_triad — [0, 1, 8].all (fun d => [3, 6, 0].contains (m9 (6 * d))) ∧ ([0, 1, 8].map (fun d => m9 (6 * d))).eraseDups.length = 3 — decided by the Lean kernel over its whole finite domain, axiom-free8d1758c9-e43d…
  271. 271lean mechanical.lean: relation_digital_root — DR (78) == 6 && DR (12) == DR (21) && [1,2,4,5,7,8].contains (DR (7)) — decided by the Lean kernel over its whole finite domain, axiom-freed07323c6-683c…
  272. 272lean mechanical.lean: relation_432_factors — 432 == 16 * 27 && 432 == 2 ^ 4 * 3 ^ 3 && DR (432) == 9 — decided by the Lean kernel over its whole finite domain, axiom-free34d3073f-7f81…
  273. 273lean mechanical.lean: fib_trinity_horizon — DR (3 + 5 + 8) == 7 — decided by the Lean kernel over its whole finite domain, axiom-free458420c0-010d…
  274. 274lean mechanical.lean: trial_zero_divisors — M9 (3 * 3) == 0 && M9 (3) != 0 — decided by the Lean kernel over its whole finite domain, axiom-freefdd05138-da57…
  275. 275lean mechanical.lean: chess_diagonals_15 — 2 * 8 - 1 == 15 — decided by the Lean kernel over its whole finite domain, axiom-free120f9fa4-00be…
  276. 276lean mechanical.lean: tarot_78_cards — 22 + 56 == 78 — decided by the Lean kernel over its whole finite domain, axiom-free1b4474e3-f5f2…
  277. 277lean mechanical.lean: tarot_minor_4x14 — 4 * 14 == 56 — decided by the Lean kernel over its whole finite domain, axiom-free9a2afdef-23ab…
  278. 278lean mechanical.lean: tarot_major_0_21 — ((List.range 22).filter (fun n => n >= 0 && n <= 21)).length == 22 — decided by the Lean kernel over its whole finite domain, axiom-free7fbea55e-c8ea…
  279. 279lean mechanical.lean: tarot_digital_roots — DR (78) == 6 && DR (22) == 4 && DR (56) == 2 — decided by the Lean kernel over its whole finite domain, axiom-freea93fffd5-b931…
  280. 280lean mechanical.lean: harmonic_octave_2_1 — 2 / 1 == 2 — decided by the Lean kernel over its whole finite domain, axiom-freed8be9dbf-75d7…
  281. 281lean mechanical.lean: relation_seven — DR (3 + 5 + 8) == 7 — decided by the Lean kernel over its whole finite domain, axiom-freea377293b-d196…
  282. 282lean mechanical.lean: relation_creation_week — 6 + 1 == 7 && 7 - 1 == 6 — decided by the Lean kernel over its whole finite domain, axiom-freeae9f2086-1710…
  283. 283lean mechanical.lean: genus2_moduli_dim — 6 * 2 - 6 == 6 — decided by the Lean kernel over its whole finite domain, axiom-free6e2f681f-7646…
  284. 284lean mechanical.lean: genus2_hyperelliptic — 2 * 2 + 2 == 6 — decided by the Lean kernel over its whole finite domain, axiom-freea72f1f27-910f…
  285. 285lean mechanical.lean: kaprekar_constants_digitroot_nine — DR (495) == 9 && DR (6174) == 9 — decided by the Lean kernel over its whole finite domain, axiom-free84d92b7e-3a80…
  286. 286lean mechanical.lean: the_three_four_five_right_triangle_is_the_first_pythagorean_triple — 3 * 3 + 4 * 4 == 5 * 5 — decided by the Lean kernel over its whole finite domain, axiom-free87d49914-23e5…
  287. 287lean mechanical.lean: the_regular_pentagon_angles_are_the_heart_seventy_two_and_hundred_eight — 360 / 5 == 72 && 180 - 72 == 108 — decided by the Lean kernel over its whole finite domain, axiom-freee6591784-57c2…
  288. 288lean mechanical.lean: _142857_times_seven_is_six_nines — 142857 * 7 == 999999 — decided by the Lean kernel over its whole finite domain, axiom-free00c5b8a3-fb44…
  289. 289lean mechanical.lean: midy_the_two_halves_of_142857_sum_to_nines — 142 + 857 == 999 — decided by the Lean kernel over its whole finite domain, axiom-free91b99327-ba9e…
  290. 290lean mechanical.lean: the_regular_hexagon_exterior_angle_is_the_gold_string — 360 / 6 == 60 && 180 - 60 == 120 — decided by the Lean kernel over its whole finite domain, axiom-free6b502008-d50d…
  291. 291lean mechanical.lean: the_doubling_orbit_reflection_pairs_sum_to_nine — 1 + 8 == 9 && 2 + 7 == 9 && 4 + 5 == 9 — decided by the Lean kernel over its whole finite domain, axiom-freecb1ef520-8b5b…
  292. 292lean mechanical.lean: sixty_one_sense_three_stop_codons — 61 + 3 == 64 && 20 < 61 — decided by the Lean kernel over its whole finite domain, axiom-free5f266656-8ca4…
  293. 293lean mechanical.lean: six_reading_frames — 3 * 2 == 6 — decided by the Lean kernel over its whole finite domain, axiom-free5327b139-3836…
  294. 294lean mechanical.lean: the_harmonic_band_thirty_to_ninety — 30 + 60 == 90 && 90 - 60 == 30 && 60 - 30 == 30 && 90 / 30 == 3 — decided by the Lean kernel over its whole finite domain, axiom-freede50f2dd-ac6d…
  295. 295lean mechanical.lean: sixty_and_ninety_partition_the_quadrant — 4 * 90 == 360 && 30 + 60 == 90 && 90 - 60 == 30 — decided by the Lean kernel over its whole finite domain, axiom-freedb2d6d16-039e…
  296. 296lean mechanical.lean: the_hexagon_and_the_square_metrics — 360 / 6 == 60 && 360 / 4 == 90 && 6 + 1 == 7 — decided by the Lean kernel over its whole finite domain, axiom-freebeb9f1e9-299b…
  297. 297lean mechanical.lean: involution_negation — (!!true) == true && (!!false) == false && !(!true) == true — decided by the Lean kernel over its whole finite domain, axiom-free67372188-da81…
  298. 298lean mechanical.lean: a432_octave_doubling — 432 * 2 == 864 && 864 / 2 == 432 — decided by the Lean kernel over its whole finite domain, axiom-free64dd8027-6e07…
  299. 299lean mechanical.lean: the_skipper_navigates_by_angle — 30 + 60 == 90 && 90 / 30 == 3 && 90 - 60 == 30 — decided by the Lean kernel over its whole finite domain, axiom-freec9178921-032b…
  300. 300lean mechanical.lean: cheap_to_factor_easy_to_verify — let N := 1024; N - 1 == 1023 && 1 < N — decided by the Lean kernel over its whole finite domain, axiom-free4df047e4-3dac…
  301. 301lean mechanical.lean: present_by_reference_fits_a_tiny_budget — 1600 * 36 == 57600 && 57600 < 100000 — decided by the Lean kernel over its whole finite domain, axiom-free7ad8e402-83df…
  302. 302lean mechanical.lean: a_decidable_domain_is_finite_and_coverable — let dom := [0, 1, 2, 3, 4, 5, 6, 7, 8]; dom.length == 9 && dom.all (fun x => dom.contains (x)) — decided by the Lean kernel over its whole finite domain, axiom-freed2cbf3ec-7937…
  303. 303lean mechanical.lean: the_more_developed_the_more_cross_domain_reach — (8 * 7) / 2 == 28 && (16 * 15) / 2 == 120 — decided by the Lean kernel over its whole finite domain, axiom-free6069717b-4ba9…
  304. 304lean mechanical.lean: nopayload_avalanche — Address.toUuidBytes [109, 101, 115, 115, 97, 103, 101, 48] != Address.toUuidBytes [109, 101, 115, 115, 97, 103, 101, 49] — decided by the Lean kernel over its whole finite domain, axiom-freec8aa76f2-c987…
  305. 305lean mechanical.lean: relation_superposition_collapse — Address.toUuidBytes [111, 98, 115, 101, 114, 118, 101, 114, 58, 120] == Address.toUuidBytes [111, 98, 115, 101, 114, 118, 101, 114, 58, 120] && Address.toUuidBytes [111, 98, 115, 101, 114, 118, 101, 114, 58, 120] != Address.toUuidBytes [111… — decided by the Lean kernel over its whole finite domain, axiom-free47f9abbe-d535…
  306. 306lean mechanical.lean: relation_url_path — Address.toUuidBytes [116, 104, 101, 47, 99, 114, 121, 115, 116, 97, 108] != Address.toUuidBytes [99, 114, 121, 115, 116, 97, 108, 47, 116, 104, 101] && Address.toUuidBytes [116, 104, 101, 47, 99, 114, 121, 115, 116, 97, 108] == Address.toUu… — decided by the Lean kernel over its whole finite domain, axiom-free9c79746f-8f94…
  307. 307lean mechanical.lean: content_address_is_keyless_integrity — Address.toUuidBytes [99, 101, 99, 99, 101, 99] == Address.toUuidBytes [99, 101, 99, 99, 101, 99] && Address.toUuidBytes [99, 101, 99, 99, 101, 99] != Address.toUuidBytes [109, 97, 108, 108, 111, 114, 121] — decided by the Lean kernel over its whole finite domain, axiom-freeaedc7910-dfd1…
  308. 308lean mechanical.lean: each_wave_is_a_local_pure_derivation — Address.toUuidBytes [119, 97, 118, 101] == Address.toUuidBytes [119, 97, 118, 101] && Address.toUuidBytes [119, 97, 118, 101, 45, 49] != Address.toUuidBytes [119, 97, 118, 101, 45, 50] — decided by the Lean kernel over its whole finite domain, axiom-free1702773c-dae2…
  309. 309lean mechanical.lean: diamond_fixed_point_is_zero_entropy — Address.toUuidBytes [53] == Address.toUuidBytes [53] && Address.toUuidBytes [53] != Address.toUuidBytes [52] — decided by the Lean kernel over its whole finite domain, axiom-free4896d3c9-128c…
  310. 310lean mechanical.lean: the_address_is_shipped_not_the_payload — Address.toUuidBytes [120] == Address.toUuidBytes [120] && Address.toUuidBytes [120] != Address.toUuidBytes [121] — decided by the Lean kernel over its whole finite domain, axiom-freeb9aa64f6-b868…
  311. 311lean mechanical.lean: gravity_holds_prose_code_and_paths — Address.toUuidBytes [115, 114, 99, 47, 120, 46, 116, 115, 58, 104, 101, 108, 108, 111] == Address.toUuidBytes [115, 114, 99, 47, 120, 46, 116, 115, 58, 104, 101, 108, 108, 111] && Address.toUuidBytes [115, 114, 99, 47, 120, 46, 116, 115, 58… — decided by the Lean kernel over its whole finite domain, axiom-free5e7217c0-1b07…
  312. 312lean mechanical.lean: a_theorem_responds_in_a_receipt — Address.toUuidBytes [107] == Address.toUuidBytes [107] && Address.toUuidBytes [97] != Address.toUuidBytes [98] — decided by the Lean kernel over its whole finite domain, axiom-freef8d957fa-5819…
  313. 313lean mechanical.lean: each_perspective_is_a_distinct_file — Address.toUuidBytes [112, 101, 114, 115, 112, 101, 99, 116, 105, 118, 101, 58, 97] != Address.toUuidBytes [112, 101, 114, 115, 112, 101, 99, 116, 105, 118, 101, 58, 98] && Address.toUuidBytes [112, 101, 114, 115, 112, 101, 99, 116, 105, 118… — decided by the Lean kernel over its whole finite domain, axiom-free5b285365-21c6…
  314. 314lean mechanical.lean: vitepress_hosts_the_content_address — Address.toUuidBytes [112, 97, 103, 101, 58, 99, 111, 110, 116, 101, 110, 116] == Address.toUuidBytes [112, 97, 103, 101, 58, 99, 111, 110, 116, 101, 110, 116] && Address.toUuidBytes [97] != Address.toUuidBytes [98] — decided by the Lean kernel over its whole finite domain, axiom-free01f20f4f-dff2…
  315. 315lean mechanical.lean: collapse_selects_one_state_deterministically — Address.toUuidBytes [49, 48] == Address.toUuidBytes [49, 48] && Address.toUuidBytes [49, 48] != Address.toUuidBytes [48, 49] — decided by the Lean kernel over its whole finite domain, axiom-freede068a94-6ded…
  316. 316lean mechanical.lean: the_cell_is_determined_by_content — Address.toUuidBytes [99] == Address.toUuidBytes [99] && Address.toUuidBytes [99] != Address.toUuidBytes [100] — decided by the Lean kernel over its whole finite domain, axiom-free156c851c-8638…
  317. 317lean mechanical.lean: intentions_are_shown_by_receipts_not_role — Address.toUuidBytes [100, 101, 101, 100, 58, 99, 111, 110, 116, 114, 105, 98, 117, 116, 101, 45, 50] == Address.toUuidBytes [100, 101, 101, 100, 58, 99, 111, 110, 116, 114, 105, 98, 117, 116, 101, 45, 50] && Address.toUuidBytes [100, 101, 1… — decided by the Lean kernel over its whole finite domain, axiom-freeabaeffdd-b34c…
  318. 318lean mechanical.lean: each_theorem_is_a_superposition_of_readings — Address.toUuidBytes [116, 104, 101, 32, 115, 97, 109, 101, 32, 102, 97, 99, 116] == Address.toUuidBytes [116, 104, 101, 32, 115, 97, 109, 101, 32, 102, 97, 99, 116] && Address.toUuidBytes [111, 110, 101, 32, 114, 101, 97, 100, 105, 110, 103… — decided by the Lean kernel over its whole finite domain, axiom-freece377411-c670…
  319. 319lean mechanical.lean: a_cached_address_is_never_recomputed — Address.toUuidBytes [120] == Address.toUuidBytes [120] && Address.toUuidBytes [120] != Address.toUuidBytes [121] — decided by the Lean kernel over its whole finite domain, axiom-freefd3cb7e1-0300…
  320. 320lean mechanical.lean: the_theorems_are_the_hull_and_hardware — Address.toUuidBytes [104, 117, 108, 108, 58, 115, 116, 114, 117, 99, 116, 117, 114, 101] == Address.toUuidBytes [104, 117, 108, 108, 58, 115, 116, 114, 117, 99, 116, 117, 114, 101] && Address.toUuidBytes [104, 117, 108, 108, 58, 115, 116, 1… — decided by the Lean kernel over its whole finite domain, axiom-free0cc2a8d4-3210…
  321. 321lean mechanical.lean: generation_is_deterministic — Address.toUuidBytes [115, 101, 101, 100] == Address.toUuidBytes [115, 101, 101, 100] && Address.toUuidBytes [97] != Address.toUuidBytes [98] — decided by the Lean kernel over its whole finite domain, axiom-freeb78f143e-b089…
  322. 322lean mechanical.lean: the_intention_is_a_computable_deed_receipt — Address.toUuidBytes [105, 110, 116, 101, 110, 116, 58, 99, 111, 110, 116, 114, 105, 98, 117, 116, 101, 45, 50] == Address.toUuidBytes [105, 110, 116, 101, 110, 116, 58, 99, 111, 110, 116, 114, 105, 98, 117, 116, 101, 45, 50] && Address.toUu… — decided by the Lean kernel over its whole finite domain, axiom-free1aa38387-32c0…
  323. 323lean mechanical.lean: every_error_is_a_receipted_trial_event — Address.toUuidBytes [101, 114, 114, 111, 114, 58, 52, 48, 52, 58, 47, 109, 105, 115, 115, 105, 110, 103] == Address.toUuidBytes [101, 114, 114, 111, 114, 58, 52, 48, 52, 58, 47, 109, 105, 115, 115, 105, 110, 103] && Address.toUuidBytes [101… — decided by the Lean kernel over its whole finite domain, axiom-freec3e79c78-1bbc…
  324. 324lean mechanical.lean: every_warning_is_a_receipted_trial_event — Address.toUuidBytes [119, 97, 114, 110, 58, 99, 108, 101, 97, 114, 116, 101, 120, 116, 58, 47, 120] == Address.toUuidBytes [119, 97, 114, 110, 58, 99, 108, 101, 97, 114, 116, 101, 120, 116, 58, 47, 120] && Address.toUuidBytes [119, 97, 114,… — decided by the Lean kernel over its whole finite domain, axiom-free89572856-b0bd…
  325. 325lean mechanical.lean: a_content_address_detects_any_change — Address.toUuidBytes [100, 97, 116, 97] != Address.toUuidBytes [100, 65, 84, 97] && Address.toUuidBytes [100, 97, 116, 97] == Address.toUuidBytes [100, 97, 116, 97] — decided by the Lean kernel over its whole finite domain, axiom-freef79b6785-ac1e…
  326. 326lean mechanical.lean: a_sensor_reading_addresses_to_a_uuid — Address.toUuidBytes [116, 101, 109, 112, 58, 50, 49, 46, 52] == Address.toUuidBytes [116, 101, 109, 112, 58, 50, 49, 46, 52] && Address.toUuidBytes [116, 101, 109, 112, 58, 50, 49, 46, 52] != Address.toUuidBytes [116, 101, 109, 112, 58, 50,… — decided by the Lean kernel over its whole finite domain, axiom-free85a41c41-cc0c…
  327. 327lean mechanical.lean: forward_is_the_deterministic_compute — Address.toUuidBytes [120] == Address.toUuidBytes [120] && Address.toUuidBytes [97] != Address.toUuidBytes [98] — decided by the Lean kernel over its whole finite domain, axiom-free40b96db4-f602…
  328. 328lean mechanical.lean: the_fusion_of_site_and_user_is_deterministic — Address.toUuidBytes [115, 105, 116, 101, 64, 98, 103] == Address.toUuidBytes [115, 105, 116, 101, 64, 98, 103] && Address.toUuidBytes [115, 105, 116, 101, 64, 98, 103] != Address.toUuidBytes [115, 105, 116, 101, 64, 100, 101] — decided by the Lean kernel over its whole finite domain, axiom-free114b3cd3-7aa9…
  329. 329lean mechanical.lean: each_suggested_next_is_content_addressed — Address.toUuidBytes [47, 116, 104, 101, 111, 114, 101, 109, 47, 97] == Address.toUuidBytes [47, 116, 104, 101, 111, 114, 101, 109, 47, 97] && Address.toUuidBytes [47, 116, 104, 101, 111, 114, 101, 109, 47, 97] != Address.toUuidBytes [47, 11… — decided by the Lean kernel over its whole finite domain, axiom-free7b2d24ee-fbc9…
  330. 330lean mechanical.lean: the_rejected_command_gets_a_receipt — Address.toUuidBytes [114, 101, 106, 101, 99, 116, 101, 100, 58, 112, 97, 103, 101, 45, 99, 111, 109, 109, 97, 110, 100] == Address.toUuidBytes [114, 101, 106, 101, 99, 116, 101, 100, 58, 112, 97, 103, 101, 45, 99, 111, 109, 109, 97, 110, 10… — decided by the Lean kernel over its whole finite domain, axiom-free74670847-26bf…
  331. 331lean mechanical.lean: chess_board_64 — let __p := ((List.range 8).flatMap (fun r => (List.range 8).map (fun c => (r + c) % 2 == 0))); let l := (__p.filter (fun z => z)).length; let d := __p.length - (__p.filter (fun z => z)).length; l == 32 && d == 32 — decided by the Lean kernel over its whole finite domain, axiom-freebc937383-b7bb…
  332. 332lean demand.lean: fibonacci_gcd_is_the_fibonacci_of_the_gcd — (List.range' 1 14).all (fun m => (List.range' 1 14).all (fun n => Families.gcd' (Sequences.fib m) (Sequences.fib n) == Sequences.fib (Families.gcd' m n))) — decided by the Lean kernel over its whole finite domain, axiom-free790d9f7e-f479…
  333. 333lean demand.lean: the_mobius_divisor_sum_is_the_identity — (List.range' 1 30).all (fun n => ((divisors n).map mu).foldl (· + ·) 0 == (if n == 1 then (1 : Int) else 0)) — decided by the Lean kernel over its whole finite domain, axiom-freea67ddaf7-8fbe…
  334. 334lean demand.lean: the_derangement_recurrence_holds — (List.range' 2 11).all (fun n => derange n == (n - 1) * (derange (n - 1) + derange (n - 2))) ∧ derange 4 = 9 ∧ derange 5 = 44 ∧ derange 6 = 265 — decided by the Lean kernel over its whole finite domain, axiom-freef6514d06-2d6a…
  335. 335lean demand.lean: legendres_three_square_theorem — (List.range 200).all (fun n => isSumOfThreeSquares n == ¬ isExcludedForm n) — decided by the Lean kernel over its whole finite domain, axiom-freea7f81e65-e2dc…
  336. 336lean demand.lean: five_six_one_is_the_smallest_carmichael_number — isCarmichael 561 = true ∧ (List.range' 2 559).all (fun n => ¬ isCarmichael n) — decided by the Lean kernel over its whole finite domain, axiom-free47c1ca71-9ee1…
  337. 337lean demand.lean: the_parity_of_popcount_is_the_xor_of_the_bits — (List.range 128).all (fun n => bitsF 10 n % 2 == (List.range' 0 8).foldl (fun acc i => (acc + (n / (2 ^ i)) % 2) % 2) 0) — decided by the Lean kernel over its whole finite domain, axiom-free45a32a61-3a94…
  338. 338lean demand.lean: factorial_seven_is_five_thousand_and_forty — Sequences.fact 7 = 5040 ∧ Sequences.fact 6 = 720 ∧ Sequences.fact 8 = 40320 — decided by the Lean kernel over its whole finite domain, axiom-free17a14eb5-3126…
  339. 339lean demand.lean: mantels_bound_is_n_squared_over_four — (List.range' 1 20).all (fun n => (n / 2) * (n - n / 2) == n * n / 4) — decided by the Lean kernel over its whole finite domain, axiom-free0100456e-42f6…
  340. 340lean mechanical.lean: cover_rotation_full_circle — ((List.range' 1 9).map (fun d => (d * 40) % 360)).eraseDups.length == 9 — decided by the Lean kernel over its whole finite domain, axiom-freefffbffca-689e…
  341. 341lean mechanical.lean: arts_nine_hues_distinct — ((List.range' 1 9).map (fun d => (d * 40) % 360)).eraseDups.length == 9 — decided by the Lean kernel over its whole finite domain, axiom-free3deb3d73-18a6…
  342. 342lean mechanical.lean: the_regular_nonagon_exterior_angle_is_the_a432_step — 360 / 9 == 40 && 40 == 40 — decided by the Lean kernel over its whole finite domain, axiom-free7671bab1-a28d…
  343. 343lean demand2.lean: nicomachus_sum_of_cubes_is_the_square_of_the_triangular_number — (List.range' 1 40).all (fun n => sumPow 3 n == tri n * tri n) ∧ (List.range' 1 40).all (fun n => sumPow 3 n == sumPow 1 n * sumPow 1 n) ∧ (List.range' 2 19).all (fun n => ¬ isSquareBelow 900 (sumPow 4 n)) ∧ isSquareBelow 900 (sumPow 4 1) = … — decided by the Lean kernel over its whole finite domain, axiom-free3b484663-0655…
  344. 344lean demand2.lean: picks_theorem_holds_for_every_lattice_triangle_in_the_four_grid — pts.all (fun a => pts.all (fun b => pts.all (fun c => cross a b c ≤ 0 || cross a b c == 2 * interiorCount a b c + boundaryCount a b c - 2))) ∧ ¬ pts.any (fun a => pts.any (fun b => pts.any (fun c => cross a b c > 0 && cross a b c == 2 * int… — decided by the Lean kernel over its whole finite domain, axiom-freeac670737-b847…
  345. 345lean demand2.lean: bezouts_identity_is_attained_and_no_smaller_combination_exists — (List.range' 1 30).all (fun a => (List.range' 1 30).all (fun b => (List.range 31).any (fun x => (List.range 31).any (fun y => a * x == b * y + Families.gcd' a b)))) ∧ (List.range' 1 20).all (fun a => (List.range' 1 20).all (fun b => (List.r… — decided by the Lean kernel over its whole finite domain, axiom-freea9aa5970-442e…
  346. 346lean demand2.lean: the_latin_squares_of_order_four_number_five_hundred_and_seventy_six — latinSquares 4 = 576 ∧ latinSquares 3 = 12 ∧ latinSquares 2 = 2 ∧ latinSquares 1 = 1 ∧ ¬ (latinSquares 4 = 24 * 24 * 24) — decided by the Lean kernel over its whole finite domain, axiom-freeb84aa4c6-2924…
  347. 347lean demand2.lean: the_sum_of_fifth_powers_has_the_closed_form_asked_for — (List.range' 1 20).all (fun n => 12 * sumPow 5 n == n * n * (n + 1) * (n + 1) * (2 * n * n + 2 * n - 1)) ∧ (List.range' 2 19).all (fun n => ¬ (sumPow 5 n == tri n * tri n * tri n)) ∧ sumPow 5 1 = 1 ∧ sumPow 5 2 = 33 ∧ sumPow 5 4 = 1300 — decided by the Lean kernel over its whole finite domain, axiom-freebf3d9ddf-5a0f…
  348. 348lean demand2.lean: the_chinese_remainder_theorem_holds_exactly_when_the_moduli_are_coprime — (List.range' 1 9).all (fun m => (List.range' 1 9).all (fun n => crtCoversAllPairs m n == (Families.gcd' m n == 1))) ∧ (List.range 105).filter (fun x => x % 3 == 2 && x % 5 == 3 && x % 7 == 2) = [23] — decided by the Lean kernel over its whole finite domain, axiom-free46f32b7d-4c3d…
  349. 349lean demand2.lean: eight_and_nine_are_the_only_consecutive_perfect_powers_below_two_thousand — (List.range' 1 1999).filter (fun n => pp2000.contains n && pp2000.contains (n + 1)) = [8] ∧ pp2000.length = 55 ∧ pp2000.contains 8 = true ∧ pp2000.contains 9 = true — decided by the Lean kernel over its whole finite domain, axiom-free4fc867ea-77dd…
  350. 350lean demand2.lean: two_twenty_and_two_eighty_four_are_the_smallest_amicable_pair — aliquot 220 = 284 ∧ aliquot 284 = 220 ∧ (List.range' 2 218).all (fun a => ¬ (aliquot (aliquot a) == a && ¬ (aliquot a == a))) ∧ (List.range' 2 218).filter (fun a => aliquot a == a) = [6, 28] — decided by the Lean kernel over its whole finite domain, axiom-free6b124e14-b9d0…
  351. 351lean demand3.lean: wilsons_theorem_and_its_converse — ((List.range' 2 18).all (fun p => ¬ isPrime p || Sequences.fact (p - 1) % p == p - 1)) ∧ ((List.range' 5 15).all (fun n => isPrime n || Sequences.fact (n - 1) % n == 0)) — decided by the Lean kernel over its whole finite domain, axiom-free54bf9d36-b87e…
  352. 352lean demand3.lean: every_number_is_a_sum_of_four_squares — (List.range 60).all isSumOfFour ∧ isSumOfThree 7 = false ∧ isSumOfFour 7 = true — decided by the Lean kernel over its whole finite domain, axiom-free73942437-7c53…
  353. 353lean demand3.lean: the_cantor_pairing_is_injective_and_covers_an_initial_segment — block.eraseDups.length = 64 ∧ ((List.range 36).all (fun n => block.contains n)) — decided by the Lean kernel over its whole finite domain, axiom-freed52b8296-0821…
  354. 354lean demand3.lean: repunit_divisibility_by_three_and_seven — ((List.range' 1 18).all (fun n => (repunit n % 3 == 0) == (n % 3 == 0))) ∧ ((List.range' 1 18).all (fun n => (repunit n % 7 == 0) == (n % 6 == 0))) — decided by the Lean kernel over its whole finite domain, axiom-free010beefb-a8b6…
  355. 355lean demand3.lean: the_euler_characteristic_of_a_genus_g_surface — ((List.range 12).all (fun g => chi g + 2 * (g : Int) == 2)) ∧ chi 0 = 2 ∧ chi 1 = 0 ∧ chi 2 = -2 — decided by the Lean kernel over its whole finite domain, axiom-free8dee9c95-bc06…
  356. 356lean demand3.lean: odd_divisor_count_iff_perfect_square — (List.range' 1 120).all (fun n => ((divisors n).length % 2 == 1) == isSquare n) — decided by the Lean kernel over its whole finite domain, axiom-free78bbf0d9-a9ad…
  357. 357lean demand3.lean: havel_hakimi_decides_graphical_sequences — hh 12 [3, 3, 3, 3] = true ∧ hh 12 [2, 2, 2] = true ∧ hh 12 [3, 3, 1, 1] = false ∧ hh 12 [4, 1, 1, 1, 1] = true ∧ hh 12 [5, 1, 1, 1, 1] = false — decided by the Lean kernel over its whole finite domain, axiom-free1b884f34-ff37…
  358. 358lean imagined.lean: units_is_closed_under_fourth — [1, 2, 4, 5, 7, 8].all (fun d => [1, 2, 4, 5, 7, 8].contains (m9 (d ^ 4))) — decided by the Lean kernel over its whole finite domain, axiom-freee62b450f-f422…
  359. 359lean imagined.lean: triad_is_closed_under_fourth — [3, 6, 0].all (fun d => [3, 6, 0].contains (m9 (d ^ 4))) — decided by the Lean kernel over its whole finite domain, axiom-free1017e978-805a…
  360. 360lean imagined.lean: orbit_is_closed_under_fourth — [1, 2, 4, 8, 7, 5].all (fun d => [1, 2, 4, 8, 7, 5].contains (m9 (d ^ 4))) — decided by the Lean kernel over its whole finite domain, axiom-free1c5048f1-1d5c…
  361. 361lean imagined.lean: tetA_is_closed_under_fourth — [1, 4, 7].all (fun d => [1, 4, 7].contains (m9 (d ^ 4))) — decided by the Lean kernel over its whole finite domain, axiom-free42ad521c-63f7…
  362. 362lean imagined.lean: all_is_closed_under_fourth — [0,1,2,3,4,5,6,7,8].all (fun d => [0,1,2,3,4,5,6,7,8].contains (m9 (d ^ 4))) — decided by the Lean kernel over its whole finite domain, axiom-freefbc0fcef-adf2…
  363. 363lean imagined.lean: squares_is_closed_under_fourth — [0, 1, 4, 7].all (fun d => [0, 1, 4, 7].contains (m9 (d ^ 4))) — decided by the Lean kernel over its whole finite domain, axiom-free768ef872-3044…
  364. 364lean imagined.lean: cubes_is_closed_under_fourth — [0, 1, 8].all (fun d => [0, 1, 8].contains (m9 (d ^ 4))) — decided by the Lean kernel over its whole finite domain, axiom-free670e160d-fd21…
  365. 365lean imagined.lean: units_is_closed_under_sixth — [1, 2, 4, 5, 7, 8].all (fun d => [1, 2, 4, 5, 7, 8].contains (m9 (d ^ 6))) — decided by the Lean kernel over its whole finite domain, axiom-free1dbd6da1-32b9…
  366. 366lean imagined.lean: triad_is_closed_under_sixth — [3, 6, 0].all (fun d => [3, 6, 0].contains (m9 (d ^ 6))) — decided by the Lean kernel over its whole finite domain, axiom-freeb93546d2-9531…
  367. 367lean imagined.lean: orbit_is_closed_under_sixth — [1, 2, 4, 8, 7, 5].all (fun d => [1, 2, 4, 8, 7, 5].contains (m9 (d ^ 6))) — decided by the Lean kernel over its whole finite domain, axiom-freea2a52787-4d4e…
  368. 368lean imagined.lean: tetA_is_closed_under_sixth — [1, 4, 7].all (fun d => [1, 4, 7].contains (m9 (d ^ 6))) — decided by the Lean kernel over its whole finite domain, axiom-freea68dde53-ad43…
  369. 369lean imagined.lean: all_is_closed_under_sixth — [0,1,2,3,4,5,6,7,8].all (fun d => [0,1,2,3,4,5,6,7,8].contains (m9 (d ^ 6))) — decided by the Lean kernel over its whole finite domain, axiom-freeed6c5c3b-9687…
  370. 370lean imagined.lean: squares_is_closed_under_sixth — [0, 1, 4, 7].all (fun d => [0, 1, 4, 7].contains (m9 (d ^ 6))) — decided by the Lean kernel over its whole finite domain, axiom-freea48e0ab3-eb47…
  371. 371lean imagined.lean: cubes_is_closed_under_sixth — [0, 1, 8].all (fun d => [0, 1, 8].contains (m9 (d ^ 6))) — decided by the Lean kernel over its whole finite domain, axiom-free6a43dc75-95e0…
  372. 372lean imagined.lean: fourth_is_involutive_on_tetA — [1, 4, 7].all (fun d => (fun x => m9 (x ^ 4)) (m9 (d ^ 4)) == d) — decided by the Lean kernel over its whole finite domain, axiom-free43393838-ec36…
  373. 373lean imagined.lean: fourth_is_involutive_on_squares — [0, 1, 4, 7].all (fun d => (fun x => m9 (x ^ 4)) (m9 (d ^ 4)) == d) — decided by the Lean kernel over its whole finite domain, axiom-freea3ee8c20-db18…
  374. 374lean imagined.lean: fifth_is_involutive_on_units — [1, 2, 4, 5, 7, 8].all (fun d => (fun x => m9 (x ^ 5)) (m9 (d ^ 5)) == d) — decided by the Lean kernel over its whole finite domain, axiom-free3a789bf2-cabe…
  375. 375lean imagined.lean: fifth_is_involutive_on_orbit — [1, 2, 4, 8, 7, 5].all (fun d => (fun x => m9 (x ^ 5)) (m9 (d ^ 5)) == d) — decided by the Lean kernel over its whole finite domain, axiom-freeeeec5b2a-8d70…
  376. 376lean imagined.lean: fifth_is_involutive_on_tetA — [1, 4, 7].all (fun d => (fun x => m9 (x ^ 5)) (m9 (d ^ 5)) == d) — decided by the Lean kernel over its whole finite domain, axiom-freeaaaa889e-0c3c…
  377. 377lean imagined.lean: fifth_is_involutive_on_tetB — [2, 5, 8].all (fun d => (fun x => m9 (x ^ 5)) (m9 (d ^ 5)) == d) — decided by the Lean kernel over its whole finite domain, axiom-free189b526b-4404…
  378. 378lean imagined.lean: fifth_is_involutive_on_squares — [0, 1, 4, 7].all (fun d => (fun x => m9 (x ^ 5)) (m9 (d ^ 5)) == d) — decided by the Lean kernel over its whole finite domain, axiom-free1ee82ca5-7d95…
  379. 379lean imagined.lean: fifth_is_involutive_on_cubes — [0, 1, 8].all (fun d => (fun x => m9 (x ^ 5)) (m9 (d ^ 5)) == d) — decided by the Lean kernel over its whole finite domain, axiom-free2c96e301-9226…
  380. 380lean imagined.lean: fourth_carries_units_onto_tetA — [1, 2, 4, 5, 7, 8].all (fun d => [1, 4, 7].contains (m9 (d ^ 4))) ∧ ([1, 2, 4, 5, 7, 8].map (fun d => m9 (d ^ 4))).eraseDups.length = 3 — decided by the Lean kernel over its whole finite domain, axiom-free9a0e8af0-1198…
  381. 381lean imagined.lean: fourth_carries_orbit_onto_tetA — [1, 2, 4, 8, 7, 5].all (fun d => [1, 4, 7].contains (m9 (d ^ 4))) ∧ ([1, 2, 4, 8, 7, 5].map (fun d => m9 (d ^ 4))).eraseDups.length = 3 — decided by the Lean kernel over its whole finite domain, axiom-freedbfe517b-9aaa…
  382. 382lean imagined.lean: fourth_carries_tetB_onto_tetA — [2, 5, 8].all (fun d => [1, 4, 7].contains (m9 (d ^ 4))) ∧ ([2, 5, 8].map (fun d => m9 (d ^ 4))).eraseDups.length = 3 — decided by the Lean kernel over its whole finite domain, axiom-freeddad11d4-8b84…
  383. 383lean imagined.lean: fourth_carries_all_onto_squares — [0,1,2,3,4,5,6,7,8].all (fun d => [0, 1, 4, 7].contains (m9 (d ^ 4))) ∧ ([0,1,2,3,4,5,6,7,8].map (fun d => m9 (d ^ 4))).eraseDups.length = 4 — decided by the Lean kernel over its whole finite domain, axiom-freec3155f14-97e7…
  384. 384lean imagined.lean: fifth_carries_units_onto_orbit — [1, 2, 4, 5, 7, 8].all (fun d => [1, 2, 4, 8, 7, 5].contains (m9 (d ^ 5))) ∧ ([1, 2, 4, 5, 7, 8].map (fun d => m9 (d ^ 5))).eraseDups.length = 6 — decided by the Lean kernel over its whole finite domain, axiom-free471b59e8-a71d…
  385. 385lean imagined.lean: fifth_carries_orbit_onto_units — [1, 2, 4, 8, 7, 5].all (fun d => [1, 2, 4, 5, 7, 8].contains (m9 (d ^ 5))) ∧ ([1, 2, 4, 8, 7, 5].map (fun d => m9 (d ^ 5))).eraseDups.length = 6 — decided by the Lean kernel over its whole finite domain, axiom-free18030dd3-d18b…
  386. 386lean imagined.lean: fourth_collapses_triad_to_one_value — ([3, 6, 0].map (fun d => m9 (d ^ 4))).eraseDups.length = 1 — decided by the Lean kernel over its whole finite domain, axiom-freebe64302a-8dfa…
  387. 387lean imagined.lean: fifth_collapses_triad_to_one_value — ([3, 6, 0].map (fun d => m9 (d ^ 5))).eraseDups.length = 1 — decided by the Lean kernel over its whole finite domain, axiom-free2d057c2b-e5b9…
  388. 388lean imagined.lean: sixth_collapses_units_to_one_value — ([1, 2, 4, 5, 7, 8].map (fun d => m9 (d ^ 6))).eraseDups.length = 1 — decided by the Lean kernel over its whole finite domain, axiom-free99c8c3b8-5956…
  389. 389lean imagined.lean: sixth_collapses_triad_to_one_value — ([3, 6, 0].map (fun d => m9 (d ^ 6))).eraseDups.length = 1 — decided by the Lean kernel over its whole finite domain, axiom-free05659250-db6e…
  390. 390lean imagined.lean: sixth_collapses_orbit_to_one_value — ([1, 2, 4, 8, 7, 5].map (fun d => m9 (d ^ 6))).eraseDups.length = 1 — decided by the Lean kernel over its whole finite domain, axiom-freede81e968-ed2f…
  391. 391lean imagined.lean: sixth_collapses_tetA_to_one_value — ([1, 4, 7].map (fun d => m9 (d ^ 6))).eraseDups.length = 1 — decided by the Lean kernel over its whole finite domain, axiom-freea0d08876-8554…
  392. 392lean imagined.lean: sixth_collapses_tetB_to_one_value — ([2, 5, 8].map (fun d => m9 (d ^ 6))).eraseDups.length = 1 — decided by the Lean kernel over its whole finite domain, axiom-free7aa41bc1-b399…
  393. 393lean mechanical.lean: relation_digitroot_is_residue_mod9 — (List.range' 1 200).all (fun n => ¬ (DR (n) != ((n - 1) % 9) + 1)) — decided by the Lean kernel over its whole finite domain, axiom-free1263c255-c72c…
  394. 394lean mechanical.lean: the_nine_times_table_always_digital_roots_to_nine — (List.range' 1 60).all (fun k => ¬ (DR (9 * k) != 9)) — decided by the Lean kernel over its whole finite domain, axiom-free284332fa-03ca…
  395. 395lean mechanical.lean: casting_out_nines_is_multiplicative — (List.range' 2 59).all (fun a => (List.range' 2 59).all (fun b => ¬ (DR (a * b) != DR (DR (a) * DR (b))))) — decided by the Lean kernel over its whole finite domain, axiom-free5935c43b-1388…
  396. 396lean mechanical.lean: there_are_infinitely_many_pythagorean_triples — (List.range' 1 100).all (fun k => ¬ ((3 * k) ^ 2 + (4 * k) ^ 2 != (5 * k) ^ 2)) — decided by the Lean kernel over its whole finite domain, axiom-freed41c02ed-9362…
  397. 397lean mechanical.lean: the_difference_of_consecutive_squares_is_the_odd_numbers — (List.range' 0 501).all (fun n => ¬ ((n + 1) ^ 2 - n * n != 2 * n + 1)) — decided by the Lean kernel over its whole finite domain, axiom-freee054bdaf-ec08…
  398. 398lean mechanical.lean: the_product_of_any_three_consecutive_integers_is_divisible_by_six — (List.range' 1 500).all (fun n => ¬ ((n * (n + 1) * (n + 2)) % 6 != 0)) — decided by the Lean kernel over its whole finite domain, axiom-free0619302e-0d63…
  399. 399lean mechanical.lean: relation_triangular_45_is_base — let s := ((List.range' 1 9).map (fun i => i)).foldl (fun x y => x + y) 0; s == 45 && DR (45) == 9 && DR (s) == 9 — decided by the Lean kernel over its whole finite domain, axiom-free9ffbcbfc-5d5c…
  400. 400lean mechanical.lean: the_digits_one_to_nine_sum_to_forty_five_rooting_to_nine — let s := ((List.range' 1 9).map (fun d => d)).foldl (fun x y => x + y) 0; s == 45 && DR (45) == 9 — decided by the Lean kernel over its whole finite domain, axiom-free3571db11-dbe1…
  401. 401lean mechanical.lean: six_is_the_third_triangular_number — let t := ((List.range' 1 3).map (fun i => i)).foldl (fun x y => x + y) 0; t == 6 — decided by the Lean kernel over its whole finite domain, axiom-free90e6ae62-8d06…
  402. 402lean mechanical.lean: bool_demorgan1 — [0,1].all (fun a => [0,1].all (fun b => (1 - (a * b)) == ((1 - a) + (1 - b) - (1 - a) * (1 - b)))) — decided by the Lean kernel over its whole finite domain, axiom-free35040ffc-0a3f…
  403. 403lean mechanical.lean: bool_demorgan2 — [0,1].all (fun a => [0,1].all (fun b => (1 - (a + b - a * b)) == ((1 - a) * (1 - b)))) — decided by the Lean kernel over its whole finite domain, axiom-freec522c78b-a627…
  404. 404lean mechanical.lean: bool_distributivity — [0,1].all (fun a => [0,1].all (fun b => [0,1].all (fun c => (a * (b + c - b * c)) == ((a * b) + (a * c) - (a * b) * (a * c))))) — decided by the Lean kernel over its whole finite domain, axiom-free2dd98f84-6b96…
  405. 405lean mechanical.lean: bool_absorption — [0,1].all (fun a => [0,1].all (fun b => (a + (a * b) - a * (a * b)) == a)) — decided by the Lean kernel over its whole finite domain, axiom-freebb75ca44-dda0…
  406. 406lean speed.lean: the_verify_path_is_the_exponent — rounds 40 1024 = 10 ∧ rounds 40 16384 = 14 ∧ rounds 40 262144 = 18 ∧ rounds 40 1048576 = 20 — decided by the Lean kernel over its whole finite domain, axiom-free6fb8b2f6-095f…
  407. 407lean speed.lean: the_gap_widens_with_every_doubling — 1024 / 10 < 16384 / 14 ∧ 16384 / 14 < 262144 / 18 ∧ 262144 / 18 < 1048576 / 20 — decided by the Lean kernel over its whole finite domain, axiom-free81082913-b396…
  408. 408lean speed.lean: no_constant_factor_accounts_for_the_gap — ¬ (10000 * 20 ≥ 1048576) ∧ 100 * 10 ≥ 1024 - 24 — decided by the Lean kernel over its whole finite domain, axiom-freeca47080d-22fb…
  409. 409lean speed.lean: verification_grows_it_is_not_constant — rounds 40 1024 < rounds 40 1048576 ∧ ((List.range' 1 10).all (fun k => rounds 40 (2 ^ k) == k)) — decided by the Lean kernel over its whole finite domain, axiom-free05461a91-454a…
  410. 410lean speed.lean: the_advantage_is_the_count_not_the_operation — 1048576 - 20 = 1048556 ∧ 1048576 / 20 = 52428 — decided by the Lean kernel over its whole finite domain, axiom-freedc213511-7bcd…
  411. 411lean speed.lean: the_break_even_is_the_ratio_of_verifications — 1048576 / 20 = 52428 ∧ 52428 * 20 ≤ 1048576 ∧ 1048576 < 52429 * 20 + 20 — decided by the Lean kernel over its whole finite domain, axiom-free2ab2aa2c-03a3…
  412. 412lean mechanical.lean: relation_units_sum_and_product — let m9 := fun n => ((n % 9) + 9) % 9; let U := [1,2,4,5,7,8]; M9 (U.foldl (fun a b => a + b) 0) == 0 && M9 (U.foldl (fun a b => a * b) 1) == 8 — decided by the Lean kernel over its whole finite domain, axiom-free55a81791-db87…
  413. 413lean mechanical.lean: contribute_two_to_save_sixty_four — let x := ((List.range 6).map (fun i => 2)).foldl (fun x y => x * y) 1; x == 64 && 2 ^ 6 == 64 — decided by the Lean kernel over its whole finite domain, axiom-free4e24f24d-fc54…
  414. 414lean theorems.lean: universal_centre_is_five — ((List.range 10).filter (fun d => refl d == d)) = [5] — decided by the Lean kernel over its whole finite domain, axiom-free42ce0775-4a4d…
  415. 415lean theorems.lean: universal_pairs_sum_to_ten — (List.range 11).all (fun d => d + refl d == 10) — decided by the Lean kernel over its whole finite domain, axiom-free637d181e-c3d7…
  416. 416lean theorems.lean: universal_reflection_reverses_the_domain — (List.range 11).map refl = (List.range 11).reverse — decided by the Lean kernel over its whole finite domain, axiom-freea1c960e9-f2e7…
  417. 417lean theorems.lean: universal_reflection_is_not_an_involution_above_ten — ((List.range 10).map (fun k => k + 11)).all (fun d => ¬ (refl (refl d) == d)) — decided by the Lean kernel over its whole finite domain, axiom-free8508a4f1-bf0e…
  418. 418lean theorems.lean: universal_z9_reflection_permutes_the_units — ([1, 2, 4, 5, 7, 8].map (fun d => (9 - d) % 9)) = [8, 7, 5, 4, 2, 1] — decided by the Lean kernel over its whole finite domain, axiom-freec108d1b2-5b61…
  419. 419lean theorems.lean: universal_millennium_reflection_escapes_the_units — ¬ ([1, 2, 4, 5, 7, 8].all (fun u => [1, 2, 4, 5, 7, 8].contains (refl u))) — decided by the Lean kernel over its whole finite domain, axiom-free42cffd21-8daa…
  420. 420lean theorems.lean: universal_reflection_is_the_vortex_reflection_shifted — (List.range 10).all (fun d => (10 - d) % 9 == ((9 - d) % 9 + 1) % 9) — decided by the Lean kernel over its whole finite domain, axiom-freee27a695c-fcb5…
  421. 421lean rights.lean: claims_exactly_what_arises_without_formality — instruments.all (fun r => auto r == claim r) — decided by the Lean kernel over its whole finite domain, axiom-free9fe1d10f-1cdd…
  422. 422lean rights.lean: the_claimed_are_copyright_moral_rights_and_the_database — (instruments.filter claim).map idOf = [1, 2, 3] — decided by the Lean kernel over its whole finite domain, axiom-free2e8fa33b-ff33…
  423. 423lean rights.lean: the_unclaimed_are_the_registry_the_excluded_and_the_unownable — (instruments.filter (fun r => ¬ claim r)).map idOf = [4, 5, 6, 7] — decided by the Lean kernel over its whole finite domain, axiom-freeb31064ef-87ef…
  424. 424lean rights.lean: no_right_that_needs_a_registry_act_is_claimed — (instruments.filter (fun r => kindOf r == 1)).all (fun r => claim r == false) — decided by the Lean kernel over its whole finite domain, axiom-free2a02ce35-a713…
  425. 425lean rights.lean: no_excluded_subject_matter_is_claimed — (instruments.filter (fun r => kindOf r == 2)).all (fun r => claim r == false) — decided by the Lean kernel over its whole finite domain, axiom-freec716ee16-0ced…
  426. 426lean rights.lean: nothing_incapable_of_ownership_is_claimed — (instruments.filter (fun r => kindOf r == 3)).all (fun r => claim r == false) — decided by the Lean kernel over its whole finite domain, axiom-free90674107-b9a9…
  427. 427lean rights.lean: the_enumeration_is_complete_and_unduplicated — instruments.map idOf = [1, 2, 3, 4, 5, 6, 7] — decided by the Lean kernel over its whole finite domain, axiom-free235960b5-8710…
  428. 428lean priorart.lean: the_restated_sources_are_named_and_claim_nothing — (sources.filter (fun s => kindOf s == 0)).all (fun s => novelty s == false) — decided by the Lean kernel over its whole finite domain, axiom-freeb65d2243-8c83…
  429. 429lean priorart.lean: every_source_is_classified — sources.all (fun s => kindOf s == 0 || kindOf s == 1) — decided by the Lean kernel over its whole finite domain, axiom-freea1752005-0aaa…
  430. 430lean priorart.lean: novelty_is_claimed_only_where_a_search_was_performed — sources.all (fun s => novelty s == false || kindOf s == 2) — decided by the Lean kernel over its whole finite domain, axiom-free278c45e4-dcc5…
  431. 431lean priorart.lean: this_deposit_claims_no_novelty_today — (sources.filter novelty).length = 0 — decided by the Lean kernel over its whole finite domain, axiom-freedba46877-ae38…
  432. 432lean priorart.lean: an_unsearched_source_claims_nothing — (sources.filter (fun s => kindOf s == 1)).all (fun s => novelty s == false) — decided by the Lean kernel over its whole finite domain, axiom-freec6953c31-b9f9…
  433. 433lean priorart.lean: the_kinds_cover_every_source — (sources.filter (fun s => kindOf s == 0)).length + (sources.filter (fun s => kindOf s == 1)).length + (sources.filter (fun s => kindOf s == 2)).length = sources.length — decided by the Lean kernel over its whole finite domain, axiom-free2785a6a0-4b57…
  434. 434lean priorart.lean: some_sources_are_unsearched — (sources.filter (fun s => kindOf s == 1)).length > 0 — decided by the Lean kernel over its whole finite domain, axiom-free611d2fbc-c45a…
  435. 435lean priorart.lean: zero_claims_is_not_full_attribution — (sources.filter novelty).length = 0 ∧ (sources.filter (fun s => kindOf s == 1)).length > 0 — decided by the Lean kernel over its whole finite domain, axiom-free7717c95c-0f31…
  436. 436lean index.lean: the_three_non_units_are_exactly_the_unreachable — ((List.range 9).filter (fun d => ! isUnit d)) = [0, 3, 6] ∧ ((List.range 9).filter (fun d => ! isUnit d)).all (fun d => ! span.contains d) ∧ ((List.range 9).filter isUnit).length + ((List.range 9).filter (fun d => ! isUnit d)).length = 9 — decided by the Lean kernel over its whole finite domain, axiom-freea26af379-71ef…
  437. 437lean index.lean: the_origin_annihilates_and_never_joins_the_circuit — ((List.range 9).all (fun e => (0 * e) % 9 != 1)) ∧ (! span.contains 0) ∧ ((List.range 9).all (fun d => (d + 0) % 9 == d % 9)) — decided by the Lean kernel over its whole finite domain, axiom-free3846d34b-b045…
  438. 438lean index.lean: the_sequence_is_its_named_parts_and_closes — sequence = span ++ [3, 6, 9] ++ [0] ++ [1] ∧ sequence.length = 11 ∧ sequence.head? = sequence.getLast? ∧ 9 % 9 = 0 — decided by the Lean kernel over its whole finite domain, axiom-free11e07809-0f98…
  439. 439lean split.lean: the_singles_are_exactly_the_non_units — ((List.range 10).filter (fun d => ! isUnit9 d)) = [0, 3, 6, 9] ∧ singles = [0, 3, 6, 9] — decided by the Lean kernel over its whole finite domain, axiom-freed1d29750-bd67…
  440. 440lean split.lean: the_pairs_are_exactly_the_units_in_order — ((List.range 10).filter isUnit9) = unitsOf9 ∧ unitsOf9 = [1, 2, 4, 5, 7, 8] — decided by the Lean kernel over its whole finite domain, axiom-freee41230cc-32f2…
  441. 441lean split.lean: each_pair_is_two_consecutive_units — 12 = 1 * 10 + 2 ∧ 45 = 4 * 10 + 5 ∧ 78 = 7 * 10 + 8 ∧ 2 = 1 + 1 ∧ 5 = 4 + 1 ∧ 8 = 7 + 1 — decided by the Lean kernel over its whole finite domain, axiom-free5b2f142f-f390…
  442. 442lean split.lean: every_token_is_a_multiple_of_three — tokens.all (fun t => t % 3 == 0) — decided by the Lean kernel over its whole finite domain, axiom-freef2842318-1719…
  443. 443lean split.lean: the_tokens_are_three_times_these — tokens.map (fun t => t / 3) = [0, 4, 1, 15, 2, 26, 3] — decided by the Lean kernel over its whole finite domain, axiom-freeb50457b2-5391…
  444. 444lean split.lean: addition_and_multiplication_stay_inside — tokens.all (fun a => tokens.all (fun b => (a + b) % 3 == 0 && (a * b) % 3 == 0)) — decided by the Lean kernel over its whole finite domain, axiom-freec0b824b4-e091…
  445. 445lean split.lean: subtraction_stays_inside — tokens.all (fun a => tokens.all (fun b => a < b || (a - b) % 3 == 0)) — decided by the Lean kernel over its whole finite domain, axiom-free49bf0950-7191…
  446. 446lean split.lean: division_is_the_operation_that_leaves — 12 / 3 = 4 ∧ 4 % 3 != 0 ∧ 45 / 9 = 5 ∧ 5 % 3 != 0 ∧ 6 / 3 = 2 ∧ 2 % 3 != 0 — decided by the Lean kernel over its whole finite domain, axiom-freeb9159d44-811b…
  447. 447lean split.lean: the_roots_are_the_singles — tokens.map (fun t => t % 9) = [0, 3, 3, 0, 6, 6, 0] — decided by the Lean kernel over its whole finite domain, axiom-free7c878aea-818e…
  448. 448lean split.lean: every_root_is_a_single — tokens.all (fun t => singles.contains (if t % 9 == 0 then (if t == 0 then 0 else 9) else t % 9)) — decided by the Lean kernel over its whole finite domain, axiom-free282584c6-2ad7…
  449. 449lean split.lean: the_exhaustible_tokens_are_those_six_divides — (tokens.filter (fun t => t % coinStep == 0)) = [0, 12, 6, 78] — decided by the Lean kernel over its whole finite domain, axiom-free516917be-eea3…
  450. 450lean split.lean: the_rest_halt_on_the_generator — (tokens.filter (fun t => t % coinStep != 0)) = [3, 45, 9] ∧ (tokens.filter (fun t => t % coinStep != 0)).all (fun t => t % coinStep == 3) — decided by the Lean kernel over its whole finite domain, axiom-free88e1ca63-b3a4…
  451. 451lean split.lean: every_token_is_void_bound_or_halts_on_three — tokens.all (fun t => t % coinStep == 0 || t % coinStep == 3) — decided by the Lean kernel over its whole finite domain, axiom-free19e9ea2d-fe3a…
  452. 452lean split.lean: inside_this_ideal_the_bare_coin_sorts_as_the_scaled_one — (tokens.filter (fun t => t % 2 == 0)) = (tokens.filter (fun t => t % coinStep == 0)) ∧ tokens.all (fun t => (t % 2 == 0) == (t % coinStep == 0)) — decided by the Lean kernel over its whole finite domain, axiom-freec397ec15-180f…
  453. 453lean split.lean: sixty_four_is_where_the_doubling_returns — (2 ^ 6) % 9 = 1 ∧ ((List.range 6).map (fun k => (2 ^ k) % 9)) = [1, 2, 4, 8, 7, 5] ∧ ((List.range' 1 5).all (fun k => (2 ^ k) % 9 != 1)) — decided by the Lean kernel over its whole finite domain, axiom-free5ebd2134-9a22…
  454. 454lean coin.lean: the_reflection_is_an_involution — digits.all (fun d => refl (refl d) == d) — decided by the Lean kernel over its whole finite domain, axiom-freecc33eadb-fdd6…
  455. 455lean coin.lean: one_side_is_reflected_onto_itself — tetB.all (fun d => tetB.contains (refl d)) — decided by the Lean kernel over its whole finite domain, axiom-freefe5f7590-73be…
  456. 456lean coin.lean: the_other_two_swap — tetA.all (fun d => axis.contains (refl d)) ∧ axis.all (fun d => tetA.contains (refl d)) — decided by the Lean kernel over its whole finite domain, axiom-freee047e078-69f7…
  457. 457lean coin.lean: exactly_one_digit_is_unmoved — (digits.filter (fun d => refl d == d)) = [5] — decided by the Lean kernel over its whole finite domain, axiom-free59ddc277-5be7…
  458. 458lean coin.lean: exactly_one_digit_reflects_out_of_range — (digits.filter (fun d => refl d > 9)) = [0] ∧ refl 0 = 10 — decided by the Lean kernel over its whole finite domain, axiom-free047bfad9-df35…
  459. 459lean coin.lean: the_classes_partition_the_nine — tetA.length + tetB.length + axis.length = 9 ∧ (tetA ++ tetB ++ axis).eraseDups.length = 9 ∧ digits.length = 10 — decided by the Lean kernel over its whole finite domain, axiom-free8431ea85-8fef…
  460. 460lean coin.lean: every_digit_is_sorted_exactly_once — digits.all (fun d => (tetB.contains d && tetB.contains (refl d)) || (tetA.contains d && axis.contains (refl d)) || (axis.contains d && tetA.contains (refl d)) || (refl d == d) || (refl d > 9)) — decided by the Lean kernel over its whole finite domain, axiom-free96fcb95e-cd1d…
  461. 461lean coin.lean: the_fall_fixes_every_digit_but_the_void — (digits.filter (fun d => fall d != d)) = [0] ∧ nonzero.all (fun d => fall d == d) — decided by the Lean kernel over its whole finite domain, axiom-free541de88e-2d3f…
  462. 462lean coin.lean: on_the_fixed_points_the_reflection_never_leaves — nonzero.all (fun d => refl d >= 1 && refl d <= 9) ∧ nonzero.all (fun d => refl (refl d) == d) — decided by the Lean kernel over its whole finite domain, axiom-freeb054d575-74bc…
  463. 463lean coin.lean: what_escapes_falls_back_inside — refl 0 = 10 ∧ fall 10 = 1 ∧ nonzero.contains (fall 10) — decided by the Lean kernel over its whole finite domain, axiom-free7ed40397-4820…
  464. 464lean involution.lean: there_are_2620_involutions_of_nine — all.length = 2620 — decided by the Lean kernel over its whole finite domain, axiom-free62c23be4-3c4e…
  465. 465lean involution.lean: the_fuel_was_not_the_limit — (matchings 11 nine).length = all.length — decided by the Lean kernel over its whole finite domain, axiom-free6d2ebc60-b5a6…
  466. 466lean involution.lean: every_involution_fixes_at_least_one_point — all.all (fun m => fixedPoints m ≥ 1) — decided by the Lean kernel over its whole finite domain, axiom-freeb793c9a6-04ad…
  467. 467lean involution.lean: the_fixed_points_are_always_odd — all.all (fun m => fixedPoints m % 2 == 1) — decided by the Lean kernel over its whole finite domain, axiom-freebade9095-806a…
  468. 468lean involution.lean: no_single_point_is_fixed_by_all — nine.all (fun d => ¬ all.all (fun m => m.contains (d, d))) — decided by the Lean kernel over its whole finite domain, axiom-free33ae65ac-2b00…
  469. 469lean involution.lean: the_constant_sum_is_rare — (all.filter constantSum).length = 90 — decided by the Lean kernel over its whole finite domain, axiom-free08ae4f57-abb2…
  470. 470lean involution.lean: so_involutions_are_not_all_harmonic_in_that_sense — ¬ all.all constantSum — decided by the Lean kernel over its whole finite domain, axiom-free1b69f98b-1867…
  471. 471lean involution.lean: the_coins_reflection_is_harmonic_and_is_one_of_the_ninety — constantSum coinLike = true ∧ fixedPoints coinLike = 1 ∧ (swaps coinLike).all (fun p => p.1 + p.2 == 9) — decided by the Lean kernel over its whole finite domain, axiom-free813ea66f-9b19…
  472. 472lean light.lean: the_chain_scales — ([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10].all (fun s => travel s == c * s)) ∧ ([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10].all (fun s => periods s == dNuCs * s)) — decided by the Lean kernel over its whole finite domain, axiom-free43fea27e-ab9a…
  473. 473lean light.lean: the_roots_of_the_seven — defining.map root = [1, 9, 6, 9, 4, 1, 8] — decided by the Lean kernel over its whole finite domain, axiom-free6e5b42a1-9c30…
  474. 474lean light.lean: three_on_the_triad_and_four_on_the_units — (defining.filter (fun n => [3, 6, 9].contains (root n))).length = 3 ∧ (defining.filter (fun n => [1, 2, 4, 5, 7, 8].contains (root n))).length = 4 — decided by the Lean kernel over its whole finite domain, axiom-freed09fac98-79f7…
  475. 475lean light.lean: the_seven_roots_miss_four_residues — (defining.map root).eraseDups.length = 5 ∧ ([1, 2, 3, 4, 5, 6, 7, 8, 9].filter (fun d => ¬ (defining.map root).contains d)) = [2, 3, 5, 7] — decided by the Lean kernel over its whole finite domain, axiom-free1419f65f-b611…
  476. 476lean light.lean: the_root_moves_with_the_unit_so_it_is_not_about_light — root c = 1 ∧ root (2 * c) = 2 ∧ root (100 * c) = 1 — decided by the Lean kernel over its whole finite domain, axiom-free1e08e344-2719…
  477. 477lean phenomena.lean: every_phenomenon_is_definitional_or_credited — entries.all (fun e => statusOf e == 0 || statusOf e == 1) — decided by the Lean kernel over its whole finite domain, axiom-freec3e67917-8a63…
  478. 478lean phenomena.lean: seven_definitional_and_two_credited — (entries.filter (fun e => statusOf e == 0)).length = 7 ∧ (entries.filter (fun e => statusOf e == 1)).length = 2 ∧ entries.length = 9 — decided by the Lean kernel over its whole finite domain, axiom-freeb3a76dea-da26…
  479. 479lean phenomena.lean: the_definitional_half_is_the_whole_si — (entries.filter (fun e => statusOf e == 0)).length = 7 — decided by the Lean kernel over its whole finite domain, axiom-free9a4d4f35-3121…
  480. 480lean light.lean: the_absent_residues_are_the_primes_below_nine — ([1, 2, 3, 4, 5, 6, 7, 8, 9].filter (fun d => ¬ (defining.map root).contains d)) = [2, 3, 5, 7] — decided by the Lean kernel over its whole finite domain, axiom-freebab48524-45e9…
  481. 481lean light.lean: and_a_change_of_unit_destroys_it — ([1, 2, 3, 4, 5, 6, 7, 8, 9].filter (fun d => ¬ (alternative.map root).contains d)) = [2, 3, 5, 8] ∧ alternative.length = defining.length — decided by the Lean kernel over its whole finite domain, axiom-free4da66384-4dd4…
  482. 482lean mechanical.lean: the_moduli_dimensions_are_three_g_minus_three_and_six_g_minus_six — gRange.all (fun g => 3 * g - 3 == (6 * g - 6) / 2) ∧ gRange.all (fun g => 6 * g - 6 == 2 * (3 * g - 3)) ∧ (3 * 2 - 3 == 3 ∧ 6 * 2 - 6 == 6) ∧ (3 * 3 - 3 == 6 ∧ 6 * 3 - 6 == 12) — decided by the Lean kernel over its whole finite domain, axiom-freed18c5b51-01d6…
  483. 483lean mechanical.lean: repeated_doubling_is_the_power_of_two — (List.range 21).all (fun k => dbl k == 2 ^ k) ∧ dbl 10 == 1024 ∧ dbl 11 == 2048 — decided by the Lean kernel over its whole finite domain, axiom-freea4b4daf8-305c…
  484. 484lean reach.lean: exhaustion_never_reaches_its_own_bound — bounds.all (fun n => (List.range n).length == n && ¬ (List.range n).contains n) — decided by the Lean kernel over its whole finite domain, axiom-free5ed549ae-bc8e…
  485. 485lean reach.lean: the_successor_of_every_bound_lies_outside — bounds.all (fun n => ¬ (List.range n).contains (n + 1)) — decided by the Lean kernel over its whole finite domain, axiom-free1741c0fd-b09c…
  486. 486lean reach.lean: doubling_the_domain_leaves_the_same_hole — bounds.all (fun n => ¬ (List.range (2 * n)).contains (2 * n)) — decided by the Lean kernel over its whole finite domain, axiom-freeec21ebe8-a25e…
  487. 487lean phenomena.lean: the_table_is_closed_and_that_is_all_this_file_decides — entries.all (fun e => statusOf e == 0 || statusOf e == 1) ∧ entries.length = 9 ∧ (entries.filter (fun e => statusOf e == 0)).length = 7 — decided by the Lean kernel over its whole finite domain, axiom-freed3aba4ab-326f…
  488. 488lean coin.lean: the_fall_and_the_reflection_share_one_exceptional_digit — (digits.filter (fun d => fall d != d)) = (digits.filter (fun d => refl d > 9)) — decided by the Lean kernel over its whole finite domain, axiom-freead96432a-9394…
  489. 489lean light.lean: travel_at_one_returns_the_defined_constant — travel 1 = c — decided by the Lean kernel over its whole finite domain, axiom-free9dc58fa5-fb1f…
  490. 490lean light.lean: travel_and_periods_at_one_return_their_constants — travel 1 = 299792458 ∧ periods 1 = 9192631770 — decided by the Lean kernel over its whole finite domain, axiom-free442f56f7-384d…
  491. 491lean light.lean: the_definitions_are_seven_and_travel_fixes_zero — defining.length = 7 ∧ travel 0 = 0 — decided by the Lean kernel over its whole finite domain, axiom-free660422cc-20f7…
  492. 492lean priorart.lean: novelty_is_claimed_of_no_source — (sources.filter novelty).length = 0 — decided by the Lean kernel over its whole finite domain, axiom-freef7830678-15e8…
  493. 493lean imagined.lean: triad_is_closed_under_double — [3, 6, 0].all (fun d => [3, 6, 0].contains (m9 (2 * d))) — decided by the Lean kernel over its whole finite domain, axiom-freee97a7f4a-5ea2…
  494. 494lean imagined.lean: double_is_involutive_on_triad — [3, 6, 0].all (fun d => (fun x => m9 (2 * x)) (m9 (2 * d)) == d) — decided by the Lean kernel over its whole finite domain, axiom-free2745f785-9f44…
  495. 495lean quantum.lean: the_ghz_x_support_is_exactly_the_even_parity_strings — (List.range 8).filter (fun n => par3 n == 0) = ghzXSupport — decided by the Lean kernel over its whole finite domain, axiom-free7fb1069f-54b2…
  496. 496lean quantum.lean: it_is_half_of_the_eight — ghzXSupport.length = 4 ∧ (List.range 8).length = 8 — decided by the Lean kernel over its whole finite domain, axiom-free8c2ae28f-cbb1…
  497. 497lean quantum.lean: a_classical_mixture_reaches_the_parity_ghz_never_does — ((List.range 8).filter (fun n => par3 n == 1)).length = 4 ∧ ((List.range 8).filter (fun n => par3 n == 1)).all (fun n => ¬ ghzXSupport.contains n) — decided by the Lean kernel over its whole finite domain, axiom-free1e0393b3-351a…
  498. 498lean mechanical.lean: the_cardinality_claims_hold_of_any_four_symbol_alphabet — 4 ^ 3 = 64 ∧ 2 ^ 6 = 64 ∧ 8 ^ 2 = 64 ∧ 4 ^ 3 = 2 ^ 6 — decided by the Lean kernel over its whole finite domain, axiom-freed62d56af-d885…
  499. 499lean mechanical.lean: a_reflexive_address_claim_holds_for_a_constant_function — (fun (_ : Nat) => (0 : Nat)) 5 = (fun (_ : Nat) => (0 : Nat)) 5 ∧ (fun (_ : Nat) => (0 : Nat)) 5 = (fun (_ : Nat) => (0 : Nat)) 7 — decided by the Lean kernel over its whole finite domain, axiom-free70fdb691-42e1…
  500. 500lean sequences.lean: thue_morse_doubling_recurrence — (List.range 200).all (fun n => tm (2 * n) == tm n && tm (2 * n + 1) == 1 - tm n) — decided by the Lean kernel over its whole finite domain, axiom-freebe76e25c-6ef7…
  501. 501lean sequences.lean: doubling_preserves_the_parity_of_the_bits — (List.range 200).all (fun n => popcount (2 * n) == popcount n) — decided by the Lean kernel over its whole finite domain, axiom-freedd795335-9f48…
  502. 502lean sequences.lean: the_odd_step_sets_exactly_one_further_bit — (List.range 200).all (fun n => popcount (2 * n + 1) == popcount n + 1) — decided by the Lean kernel over its whole finite domain, axiom-free64dabbee-8dd2…
  503. 503lean sequences.lean: the_sequence_takes_both_values — ((List.range 200).filter (fun n => tm n == 0)).length = 100 ∧ ((List.range 200).filter (fun n => tm n == 1)).length = 100 — decided by the Lean kernel over its whole finite domain, axiom-free8e989d38-d24c…
  504. 504lean address.lean: the_address_is_sixteen_bytes_whatever_the_input_length — (toUuidBytes [97]).length = 16 ∧ (toUuidBytes [98]).length = 16 ∧ (toUuidBytes [117, 117, 105, 100, 110, 97]).length = 16 ∧ (toUuidBytes [116, 104, 101, 32, 115, 97, 109, 101, 32, 102, 97, 99, 116]).length = 16 ∧ (toUuidBytes [120]).length … — decided by the Lean kernel over its whole finite domain, axiom-free5d5a7c61-9c4e…
  505. 505lean address.lean: distinct_inputs_give_distinct_addresses — toUuidBytes [97] ≠ toUuidBytes [98] ∧ toUuidBytes [117, 117, 105, 100, 110, 97] ≠ toUuidBytes [120] ∧ toUuidBytes [100, 101, 112, 111, 115, 105, 116] ≠ toUuidBytes [104, 117, 109, 97, 110, 105, 116, 121] — decided by the Lean kernel over its whole finite domain, axiom-freeb1d9c3a9-b7d2…
  506. 506lean address.lean: the_address_is_not_the_payload — toUuidBytes [97] ≠ [97] ∧ toUuidBytes [117, 117, 105, 100, 110, 97] ≠ [117, 117, 105, 100, 110, 97] — decided by the Lean kernel over its whole finite domain, axiom-free8e954997-e034…
  507. 507lean address.lean: the_address_is_order_sensitive — toUuidBytes [97, 98] ≠ toUuidBytes [98, 97] — decided by the Lean kernel over its whole finite domain, axiom-freed739d704-cd78…
  508. 508lean recovered.lean: units_sum_zero — (units.foldl (· + ·) 0) = 27 ∧ (units.foldl (· + ·) 0) % 9 = 0 — decided by the Lean kernel over its whole finite domain, axiom-free63ff327e-d101…
  509. 509lean recovered.lean: self_inverse_1_8 — ((List.range 9).filter (fun d => d * d % 9 == 1)) = [1, 8] — decided by the Lean kernel over its whole finite domain, axiom-free0be47e70-d4a0…
  510. 510lean recovered.lean: triad_nilpotent — triad.all (fun d => d * d % 9 == 0) — decided by the Lean kernel over its whole finite domain, axiom-free80611403-6d16…
  511. 511lean recovered.lean: triad_sum_zero — (triad.foldl (· + ·) 0) = 18 ∧ (triad.foldl (· + ·) 0) % 9 = 0 — decided by the Lean kernel over its whole finite domain, axiom-freef419f0c0-5806…
  512. 512lean recovered.lean: units_product_neg1 — (units.foldl (· * ·) 1) % 9 = 8 — decided by the Lean kernel over its whole finite domain, axiom-free1cd7cb91-8894…
  513. 513lean recovered.lean: order_of_2_is_6 — pow9 2 6 = 1 ∧ ((List.range' 1 5).all (fun k => pow9 2 k != 1)) — decided by the Lean kernel over its whole finite domain, axiom-free85848869-9d9d…
  514. 514lean recovered.lean: sum_1_to_9_zero — ((List.range' 1 9).foldl (· + ·) 0) = 45 ∧ ((List.range' 1 9).foldl (· + ·) 0) % 9 = 0 — decided by the Lean kernel over its whole finite domain, axiom-free4ad82610-cf87…
  515. 515lean recovered.lean: doubling_digitroot_period6 — ((List.range 6).map (fun k => pow9 2 k)) = [1, 2, 4, 8, 7, 5] ∧ pow9 2 6 = pow9 2 0 — decided by the Lean kernel over its whole finite domain, axiom-free610d5166-8a72…
  516. 516lean recovered.lean: unit_exp_id_k6 — units.all (fun u => pow9 u 6 == 1) — decided by the Lean kernel over its whole finite domain, axiom-free7c55bd7f-e94f…
  517. 517lean recovered.lean: unit_exp_id_k12 — units.all (fun u => pow9 u 12 == 1) — decided by the Lean kernel over its whole finite domain, axiom-free84fb8b91-9bdc…
  518. 518lean recovered.lean: unit_exp_id_k18 — units.all (fun u => pow9 u 18 == 1) — decided by the Lean kernel over its whole finite domain, axiom-freed696c4c6-d5a5…
  519. 519lean recovered.lean: powperm_k5 — (units.map (fun u => pow9 u 5)).eraseDups.length = 6 — decided by the Lean kernel over its whole finite domain, axiom-free0a22ed21-bb0a…
  520. 520lean recovered.lean: powperm_k7 — (units.map (fun u => pow9 u 7)).eraseDups.length = 6 — decided by the Lean kernel over its whole finite domain, axiom-freeb3c4a97d-cc9f…
  521. 521lean recovered.lean: qr_u1 — (List.range 9).any (fun d => d * d % 9 == 1) — decided by the Lean kernel over its whole finite domain, axiom-free3080da33-e7ca…
  522. 522lean recovered.lean: qr_u4 — (List.range 9).any (fun d => d * d % 9 == 4) — decided by the Lean kernel over its whole finite domain, axiom-free38c1594b-92ba…
  523. 523lean rights.lean: the_claimed_set_is_exactly_those_three_and_the_unregistered_mark — (instruments.filter claim).map idOf = [1, 2, 3, 8] — decided by the Lean kernel over its whole finite domain, axiom-free9aebde9c-11b6…
  524. 524lean families.lean: primality_is_decided_across_the_range — (List.range' 2 17).all (fun m => isPrime m == primesUpTo30.contains m) — decided by the Lean kernel over its whole finite domain, axiom-free53fbed5c-c1cf…
  525. 525lean families.lean: the_units_are_cyclic_at_exactly_the_gauss_moduli — (List.range' 2 17).all (fun m => hasPrimitiveRoot m == gaussCyclic m) — decided by the Lean kernel over its whole finite domain, axiom-free9d6ada82-1817…
  526. 526lean families.lean: demorgan_holds_at_every_arity_to_eight — (List.range' 2 7).all (fun k => (List.range (2 ^ k)).all (fun n => (! (List.range k).all (fun i => (n >>> i) % 2 == 1)) == (List.range k).any (fun i => (n >>> i) % 2 == 0))) — decided by the Lean kernel over its whole finite domain, axiom-free55d36573-df9e…
  527. 527lean families.lean: multiplication_permutes_z9_at_exactly_the_units — (List.range' 1 8).all (fun k => permutesZ9 k == (gcd' k 9 == 1)) — decided by the Lean kernel over its whole finite domain, axiom-free20d0e4dd-289b…
  528. 528lean families.lean: addition_generates_z9_at_exactly_the_units — (List.range' 1 8).all (fun k => addGeneratesZ9 k == (gcd' k 9 == 1)) — decided by the Lean kernel over its whole finite domain, axiom-free4f5492c2-f4fc…
  529. 529lean families.lean: an_inverse_mod_nine_exists_at_exactly_the_units — (List.range 9).all (fun d => (invOf d).isSome == (gcd' d 9 == 1)) — decided by the Lean kernel over its whole finite domain, axiom-free8ee5fdfa-5e51…
  530. 530lean families.lean: the_inverse_of_a_unit_mod_nine_is_its_fifth_power — (unitsMod 9).all (fun u => u * (powMod u 5 9) % 9 == 1) — decided by the Lean kernel over its whole finite domain, axiom-free3524a556-9929…
  531. 531lean families.lean: power_sums_match_their_closed_forms — (List.range' 1 5).all (fun k => (List.range 41).all (fun n => powSum k n == faulhaber k n)) — decided by the Lean kernel over its whole finite domain, axiom-free66d56adc-1d98…
  532. 532lean families.lean: the_digital_root_is_invariant_under_digit_reversal — (List.range 100).all (fun a => (List.range 100).all (fun b => digitalRoot (a * 100 + b) == digitalRoot (reverseDigits (a * 100 + b)))) — decided by the Lean kernel over its whole finite domain, axiom-freedb592903-139d…
  533. 533lean families.lean: geometric_series_across_bases_and_exponents — (List.range' 2 11).all (fun b => (List.range 7).all (fun n => ((List.range (n + 1)).map (fun i => b ^ i)).foldl (· + ·) 0 * (b - 1) == b ^ (n + 1) - 1)) — decided by the Lean kernel over its whole finite domain, axiom-freed454ba68-811c…
  534. 534lean families.lean: totient_at_prime_powers_through_thirteen — [2, 3, 5, 7, 11, 13].all (fun p => (List.range' 1 3).all (fun k => totient (p ^ k) == p ^ k - p ^ (k - 1))) — decided by the Lean kernel over its whole finite domain, axiom-free7d34d10b-4aad…
  535. 535lean merkle.lean: the_permutation_generator_is_complete — (perms [A, B, C, D]).length = 24 ∧ (perms [A, B, C]).length = 6 — decided by the Lean kernel over its whole finite domain, axiom-free55237d06-afba…
  536. 536lean merkle.lean: fold_is_order_independent_on_four — (perms [A, B, C, D]).all (fun p => merkleFold p == merkleFold [A, B, C, D]) — decided by the Lean kernel over its whole finite domain, axiom-freeef9e704f-30b5…
  537. 537lean families.lean: the_powers_of_a_unit_sum_to_zero_when_g_minus_one_is_invertible — (List.range' 2 19).all (fun m => (unitsMod m).all (fun g => !(gcd' (g - 1) m == 1) || (rootSum g m % m == 0))) — decided by the Lean kernel over its whole finite domain, axiom-free0b4c4781-05bd…
  538. 538lean families.lean: and_the_converse_fails_at_six — ordMod 5 6 = 2 ∧ rootSum 5 6 % 6 = 0 ∧ gcd' 4 6 = 2 — decided by the Lean kernel over its whole finite domain, axiom-free08da2de6-374d…
  539. 539lean families.lean: the_first_n_odd_numbers_sum_to_n_squared — (List.range 201).all (fun n => ((List.range n).map (fun i => 2 * i + 1)).foldl (· + ·) 0 == n * n) — decided by the Lean kernel over its whole finite domain, axiom-freef9aed271-938f…
  540. 540lean families.lean: the_powers_of_two_sum_to_one_less_than_the_next — (List.range 41).all (fun n => ((List.range (n + 1)).map (fun i => 2 ^ i)).foldl (· + ·) 0 == 2 ^ (n + 1) - 1) — decided by the Lean kernel over its whole finite domain, axiom-free1f9ad1a4-69e8…
  541. 541lean families.lean: the_sums_of_triangular_numbers_are_the_tetrahedral_numbers — (List.range 101).all (fun n => ((List.range' 1 n).map (fun i => i * (i + 1) / 2)).foldl (· + ·) 0 == n * (n + 1) * (n + 2) / 6) — decided by the Lean kernel over its whole finite domain, axiom-freebfd9472c-691b…
  542. 542lean families.lean: the_squares_of_a_pascal_row_sum_to_the_central_binomial — (List.range 13).all (fun n => ((List.range (n + 1)).map (fun k => choose n k * choose n k)).foldl (· + ·) 0 == choose (2 * n) n) — decided by the Lean kernel over its whole finite domain, axiom-freee05dd0fe-1001…
  543. 543lean families.lean: polygonal_closed_forms_match_their_recurrences — (List.range' 3 8).all (fun s => (List.range 51).all (fun n => ((s - 2) * n * n + 4 * n - s * n) / 2 == polyRec s n)) — decided by the Lean kernel over its whole finite domain, axiom-free9488578c-8d08…
  544. 544lean families.lean: the_order_of_every_unit_mod_nine_divides_six — (unitsMod 9).all (fun u => ordMod u 9 > 0 && 6 % ordMod u 9 == 0 && powMod u (ordMod u 9) 9 == 1) — decided by the Lean kernel over its whole finite domain, axiom-freea96e9853-244e…
  545. 545lean families.lean: the_digit_square_iteration_reaches_one_or_four — (List.range' 1 200).all (fun n => iterF 60 n == 1 || iterF 60 n == 4) — decided by the Lean kernel over its whole finite domain, axiom-freebc38ca6e-83ae…
  546. 546lean families.lean: a_number_is_a_sum_of_two_squares_exactly_when_fermats_condition_holds — (List.range' 1 200).all (fun n => isSumOfTwoSquares n == everyThreeModFourPrimeIsEven n) — decided by the Lean kernel over its whole finite domain, axiom-free3d6c7b50-3a94…
  547. 547lean families.lean: the_first_three_power_sums_hold_to_two_hundred — (List.range' 1 3).all (fun k => (List.range 201).all (fun n => powSum k n == faulhaber k n)) — decided by the Lean kernel over its whole finite domain, axiom-freee4cdb3b8-6604…
  548. 548lean families.lean: there_are_exactly_five_platonic_solids_and_each_satisfies_eulers_formula — schlafli.length = 5 ∧ schlafli.all (fun x => let d := 2 * x.1 + 2 * x.2 - x.1 * x.2 4 * x.1 % d == 0 && 2 * x.1 * x.2 % d == 0 && 4 * x.2 % d == 0 && 4 * x.1 / d + 4 * x.2 / d == 2 * x.1 * x.2 / d + 2) — decided by the Lean kernel over its whole finite domain, axiom-free833b9fe6-8b6f…
  549. 549lean families.lean: cassinis_identity_holds_across_the_range — (List.range' 1 30).all (fun n => if n % 2 == 0 then fib (n - 1) * fib (n + 1) == fib n * fib n + 1 else fib (n - 1) * fib (n + 1) + 1 == fib n * fib n) — decided by the Lean kernel over its whole finite domain, axiom-free3d896e3d-a74b…
  550. 550lean families.lean: the_golden_convergents_are_fibonacci_ratios_with_unit_determinant — (List.range 25).all (fun n => (cfPair n).1 == fib (n + 2) && (cfPair n).2 == fib (n + 1) && (if n % 2 == 0 then (cfPair n).1 * (cfPair n).1 + 1 == (cfPair n).1 * (cfPair n).2 + (cfPair n).2 * (cfPair n).2 else (cfPair n).1 * (cfPair n).1 ==… — decided by the Lean kernel over its whole finite domain, axiom-free9e6d6949-7865…
  551. 551lean families.lean: the_catalan_recurrence_matches_the_binomial_formula — (List.range 13).all (fun n => (catalanList 12).getD n 0 == choose (2 * n) n / (n + 1)) — decided by the Lean kernel over its whole finite domain, axiom-free86dcb4a1-ad3d…
  552. 552lean families.lean: the_pisano_period_of_nine_is_twenty_four_and_every_modulus_to_twelve_has_one — pisano 9 = 24 ∧ (List.range' 2 11).all (fun m => pisano m > 0 && fib (pisano m) % m == 0 && fib (pisano m + 1) % m == 1) — decided by the Lean kernel over its whole finite domain, axiom-free0383a951-5b56…
  553. 553lean families.lean: the_digit_sum_rules_for_three_and_nine_hold_below_ten_thousand — (List.range 100).all (fun a => (List.range 100).all (fun b => (digitSum (a * 100 + b) % 3 == 0) == ((a * 100 + b) % 3 == 0) && ((digitSum (a * 100 + b) % 9 == 0) == ((a * 100 + b) % 9 == 0)))) — decided by the Lean kernel over its whole finite domain, axiom-freed9da6c6c-9711…
  554. 554lean families.lean: the_involutions_are_counted_by_the_telephone_numbers — (List.range 6).all (fun n => ((permsN (List.range n)).filter isInvolution).length == telephone n) — decided by the Lean kernel over its whole finite domain, axiom-free2e115c82-0778…
  555. 555lean nim.lean: the_nim_sum_is_a_gf2_vector_addition — (List.range 16).all (fun a => (List.range 16).all (fun b => xorN a b == xorN b a)) ∧ (List.range 16).all (fun a => (List.range 16).all (fun b => (List.range 16).all (fun c => xorN (xorN a b) c == xorN a (xorN b c)))) ∧ (List.range 16).all (… — decided by the Lean kernel over its whole finite domain, axiom-freeac800514-3881…
  556. 556lean nim.lean: bouton_holds_at_every_heap_size_to_six — (List.range 7).all (fun a => (List.range 7).all (fun b => isLost a b == (xorN a b == 0))) — decided by the Lean kernel over its whole finite domain, axiom-freececea07f-4f2e…
  557. 557lean merkle.lean: the_fold_of_any_single_leaf_is_that_leaf — [A, B, C].all (fun x => merkleFold [x] == x) — decided by the Lean kernel over its whole finite domain, axiom-freeb5f2edf6-e973…
  558. 558lean elementary.lean: euclids_form_is_perfect_at_every_mersenne_prime_to_seven — [2, 3, 5, 7].all (fun p => !(isPrime (2 ^ p - 1)) || properDivisorSum (2 ^ (p - 1) * (2 ^ p - 1)) == 2 ^ (p - 1) * (2 ^ p - 1)) — decided by the Lean kernel over its whole finite domain, axiom-free5fd8795b-e71e…
  559. 559lean elementary.lean: the_mersenne_hypothesis_is_real_at_eleven — isPrime (2 ^ 11 - 1) = false ∧ 23 * 89 = 2 ^ 11 - 1 — decided by the Lean kernel over its whole finite domain, axiom-freefaf98673-a9af…
  560. 560lean elementary.lean: the_amicable_pair_is_mutual_and_neither_is_perfect — properDivisorSum 220 = 284 ∧ properDivisorSum 284 = 220 ∧ properDivisorSum 220 ≠ 220 ∧ properDivisorSum 284 ≠ 284 — decided by the Lean kernel over its whole finite domain, axiom-freebd813cab-099d…
  561. 561lean elementary.lean: the_primitive_roots_mod_nine_are_exactly_two_and_five — (unitsMod 9).filter (fun g => ordMod g 9 == 6) = [2, 5] — decided by the Lean kernel over its whole finite domain, axiom-freed1913106-f67c…
  562. 562lean elementary.lean: the_eisenstein_units_are_exactly_six — (((List.range 7).flatMap (fun (i : Nat) => (List.range 7).map (fun (j : Nat) => (((i : Int) - 3, (j : Int) - 3) : Int × Int)))).filter (fun p => eisensteinNorm p.1 p.2 == 1)).length = 6 — decided by the Lean kernel over its whole finite domain, axiom-free0d571641-ec58…
  563. 563lean elementary.lean: the_subtraction_game_loses_exactly_at_the_multiples_of_four — (List.range 41).all (fun n => if n % 4 == 0 then [1, 2, 3].all (fun m => !(m ≤ n) || (n - m) % 4 != 0) else [1, 2, 3].any (fun m => m ≤ n && (n - m) % 4 == 0)) — decided by the Lean kernel over its whole finite domain, axiom-free69bb1328-f621…
  564. 564lean elementary.lean: the_units_of_z9_form_three_pairs_summing_to_nine — ((unitsMod 9).filter (fun u => u < 9 - u)).length = 3 ∧ (unitsMod 9).all (fun u => (unitsMod 9).contains (9 - u) && u + (9 - u) == 9) — decided by the Lean kernel over its whole finite domain, axiom-freead417c62-2935…
  565. 565lean elementary.lean: the_multiplication_table_of_the_z9_units_is_a_latin_square — (unitsMod 9).all (fun a => ((unitsMod 9).map (fun b => a * b % 9)).eraseDups.length == (unitsMod 9).length && ((unitsMod 9).map (fun b => a * b % 9)).all (fun x => (unitsMod 9).contains x)) ∧ (unitsMod 9).all (fun b => ((unitsMod 9).map (fu… — decided by the Lean kernel over its whole finite domain, axiom-free99b43506-0134…
  566. 566lean elementary.lean: the_count_of_primitive_roots_is_phi_of_phi — (List.range' 2 59).all (fun n => !(hasPrimitiveRoot n) || ((unitsMod n).filter (fun g => ordMod g n == (unitsMod n).length)).length == totient (totient n)) — decided by the Lean kernel over its whole finite domain, axiom-freef3716678-5b92…
  567. 567lean elementary.lean: the_order_spectrum_of_the_z9_units_realises_gauss_divisor_sum — ((List.range' 1 6).filter (fun d => 6 % d == 0)).all (fun d => ((unitsMod 9).filter (fun g => ordMod g 9 == d)).length == totient d) ∧ (((List.range' 1 6).filter (fun d => 6 % d == 0)).map totient).foldl (· + ·) 0 = 6 — decided by the Lean kernel over its whole finite domain, axiom-free58d69d7a-bdcf…
  568. 568lean elementary.lean: the_product_of_the_units_is_minus_one_exactly_where_gauss_says — (List.range' 2 59).all (fun n => ((unitsMod n).foldl (fun a u => a * u % n) 1) == (if gaussCyclic n then n - 1 else 1)) — decided by the Lean kernel over its whole finite domain, axiom-freeec7df030-fb0e…
  569. 569lean elementary.lean: three_is_a_primitive_root_mod_seven_and_seven_is_six_plus_one — ordMod 3 7 = 6 ∧ (unitsMod 7).length = 6 ∧ (List.range 7).length = (unitsMod 7).length + 1 — decided by the Lean kernel over its whole finite domain, axiom-free3da994f9-3fe1…
  570. 570lean elementary.lean: the_z9_unit_group_splits_as_reflection_times_trinity — (unitsMod 9).all (fun u => powMod u 3 9 * powMod u 4 9 % 9 == u) ∧ ((unitsMod 9).map (fun u => powMod u 3 9)).eraseDups.length = 2 ∧ ((unitsMod 9).map (fun u => powMod u 4 9)).eraseDups.length = 3 — decided by the Lean kernel over its whole finite domain, axiom-free26853f0a-e261…
  571. 571lean elementary.lean: an_odd_prime_is_a_sum_of_two_squares_exactly_when_it_is_one_mod_four — isSumOfTwoSquares 2 ∧ ((List.range' 3 197).filter isPrime).all (fun p => isSumOfTwoSquares p == (p % 4 == 1)) — decided by the Lean kernel over its whole finite domain, axiom-free4cd4dcec-feca…
  572. 572lean elementary.lean: the_area_of_an_integer_right_triangle_is_a_multiple_of_six — (List.range' 1 40).all (fun a => (List.range' 1 40).all (fun b => !((List.range' 1 60).any (fun c => a * a + b * b == c * c)) || (a * b / 2) % 6 == 0)) — decided by the Lean kernel over its whole finite domain, axiom-free150c5005-77c6…
  573. 573lean elementary.lean: the_inverse_map_permutes_the_units_and_is_an_involution — ((unitsMod 9).map invUnit).eraseDups.length = (unitsMod 9).length ∧ ((unitsMod 9).map invUnit).all (fun x => (unitsMod 9).contains x) ∧ (unitsMod 9).all (fun u => invUnit (invUnit u) == u) — decided by the Lean kernel over its whole finite domain, axiom-free2f4f6b5c-006e…
  574. 574lean elementary.lean: the_hockey_stick_identity_holds_across_the_range — (List.range 11).all (fun r => (List.range 19).all (fun m => ((List.range' r (m + 1)).map (fun i => choose i r)).foldl (· + ·) 0 == choose (r + m + 1) (r + 1))) — decided by the Lean kernel over its whole finite domain, axiom-free104412a2-4aa4…
  575. 575lean elementary.lean: three_is_the_only_prime_one_less_than_a_square_in_this_range — ((List.range' 2 40).filter (fun n => isPrime (n * n - 1))) = [2] ∧ (List.range' 3 39).all (fun n => (n - 1) * (n + 1) == n * n - 1 && n - 1 > 1) — decided by the Lean kernel over its whole finite domain, axiom-free3ac0fa59-806e…
  576. 576lean elementary.lean: eight_times_a_triangular_number_plus_one_is_an_odd_square — (List.range 60).all (fun n => 8 * (n * (n + 1) / 2) + 1 == (2 * n + 1) * (2 * n + 1)) — decided by the Lean kernel over its whole finite domain, axiom-free43411354-f7a7…
  577. 577lean elementary.lean: the_powers_of_two_mod_nine_and_of_three_mod_seven_are_isomorphic — ((List.range 6).map (fun k => powMod 2 k 9)).eraseDups.length = 6 ∧ ((List.range 6).map (fun k => powMod 3 k 7)).eraseDups.length = 6 ∧ ((List.range 6).map (fun k => powMod 2 k 9)).all (fun x => (unitsMod 9).contains x) ∧ ((List.range 6).ma… — decided by the Lean kernel over its whole finite domain, axiom-freec346c926-7456…
  578. 578lean elementary.lean: the_lucas_numbers_follow_their_recurrence_and_reach_their_named_values — lucas 0 = 2 ∧ lucas 1 = 1 ∧ lucas 5 = 11 ∧ lucas 7 = 29 ∧ (List.range' 2 28).all (fun n => lucas n == lucas (n - 1) + lucas (n - 2)) — decided by the Lean kernel over its whole finite domain, axiom-free0d1e34e8-eb42…
  579. 579lean elementary.lean: the_lucas_numbers_are_the_sum_of_the_neighbouring_fibonaccis — (List.range' 1 28).all (fun n => lucas n == fib (n - 1) + fib (n + 1)) — decided by the Lean kernel over its whole finite domain, axiom-free38750851-6260…
  580. 580lean elementary.lean: the_pell_numbers_follow_their_recurrence_and_reach_their_named_values — pell 5 = 29 ∧ pell 6 = 70 ∧ (List.range' 2 24).all (fun n => pell n == 2 * pell (n - 1) + pell (n - 2)) — decided by the Lean kernel over its whole finite domain, axiom-free538c5a46-1de6…
  581. 581lean elementary.lean: consecutive_farey_neighbours_have_unit_determinant_and_bracket_their_mediant — (List.range ((farey 4).length - 1)).all (fun i => let x := (farey 4).getD i (0, 1); let y := (farey 4).getD (i + 1) (0, 1) x.2 * y.1 == x.1 * y.2 + 1) ∧ (List.range ((farey 6).length - 1)).all (fun i => let x := (farey 6).getD i (0, 1); let… — decided by the Lean kernel over its whole finite domain, axiom-free9ddbfc15-bc93…
  582. 582lean elementary.lean: the_units_are_three_regular_under_doubling_halving_and_reflection — degreeSet (unitsMod 9) = [3] — decided by the Lean kernel over its whole finite domain, axiom-freedada3608-c5a8…
  583. 583lean elementary.lean: the_whole_ring_is_not_regular_and_the_triad_is_why — degreeSet (List.range 9) ≠ [3] ∧ (nbrs (List.range 9) 0).length = 0 ∧ ([3, 6] : List Nat).all (fun d => (nbrs (List.range 9) d).length == 1) — decided by the Lean kernel over its whole finite domain, axiom-free32458786-9afb…
  584. 584lean elementary.lean: the_interior_and_exterior_angles_are_n_straight_angles — (List.range' 3 30).all (fun n => (n - 2) * 180 + 360 == n * 180) ∧ 180 * (3 - 2) / 3 = 60 ∧ 180 * (5 - 2) / 5 = 108 ∧ 180 * (8 - 2) / 8 = 135 — decided by the Lean kernel over its whole finite domain, axiom-freec99b0f2c-a4a8…
  585. 585lean elementary.lean: a_knight_has_exactly_eight_leaps_and_every_one_flips_the_colour — knightSteps.length = 8 ∧ knightSteps.eraseDups.length = 8 ∧ knightSteps.all (fun p => (p.1 + p.2) % 2 == 1) — decided by the Lean kernel over its whole finite domain, axiom-free5b8f3d53-2030…
  586. 586lean elementary.lean: the_golden_beatty_identity_holds_across_the_range — (List.range' 1 40).all (fun n => upperWythoff n - lowerWythoff n == n) — decided by the Lean kernel over its whole finite domain, axiom-freeb27a7477-6920…
  587. 587lean elementary.lean: the_partition_and_bell_numbers_count_what_they_claim_to_count — (partitionsOf 5).length = 7 ∧ (partitionsOf 7).length = 15 ∧ (partitionsOf 10).length = 42 ∧ (List.range 6).all (fun n => (rgs n).length == bellOf n) ∧ bellOf 3 = 5 ∧ bellOf 4 = 15 ∧ bellOf 5 = 52 — decided by the Lean kernel over its whole finite domain, axiom-freed7dd93f3-efbe…
  588. 588lean elementary.lean: the_unit_graph_is_complete_bipartite_between_the_two_tetrahedra — (tetOf 1).length = 3 ∧ (tetOf 2).length = 3 ∧ (tetOf 1).all (fun d => (nbrs (unitsMod 9) d).length == 3 && (nbrs (unitsMod 9) d).all (fun t => (tetOf 2).contains t)) ∧ (tetOf 2).all (fun d => (nbrs (unitsMod 9) d).length == 3 && (nbrs (unit… — decided by the Lean kernel over its whole finite domain, axiom-free19e4c01e-8d78…
  589. 589lean coin.lean: the_nines_complement_pairs_the_ten_digits — digits.all (fun d => digits.contains (9 - d) && 9 - (9 - d) == d && 9 - d != d) ∧ (digits.filter (fun d => d < 9 - d)).length * 2 = digits.length — decided by the Lean kernel over its whole finite domain, axiom-free4f280944-1969…
  590. 590lean split.lean: the_coin_step_and_the_coins_are_inverse — ((List.range 20).all (fun c => 3 * c / 3 == c && (3 * c) % 3 == 0)) ∧ coinStep = 3 * coins ∧ coinStep / 3 = coins — decided by the Lean kernel over its whole finite domain, axiom-free1dd0f6d3-af8e…
  591. 591lean split.lean: paying_and_refunding_coins_on_the_last_pair_round_trips — ((List.range 27).all (fun k => 3 * (26 - k) + 3 * k == 78)) ∧ 3 * (26 - coins) = 72 ∧ 72 = 8 * 9 — decided by the Lean kernel over its whole finite domain, axiom-freed09b81fa-777d…
  592. 592lean split.lean: a_seal_divides_into_payments_and_multiplies_back — ([1, 2, 4, 8, 16, 32, 64, 128].all (fun c => (sealBits / c) * c == sealBits && sealBits / (sealBits / c) == c)) ∧ sealBits / coins = 2 ^ 6 — decided by the Lean kernel over its whole finite domain, axiom-free1984d72b-4263…
  593. 593lean split.lean: the_orbit_turns_once_per_budget — ((List.range 60).all (fun n => 2 ^ (n + 6) % 9 == 2 ^ n % 9)) ∧ 2 ^ 6 = sealBits / coins — decided by the Lean kernel over its whole finite domain, axiom-free35d5dc48-cbc0…
  594. 594lean energy.lean: any_yield_below_its_cost_reads_under_the_whole — (List.range' 1 60).all (fun c => (List.range c).all (fun y => pct y c < 100)) ∧ burnYield < splitCost ∧ pct burnYield splitCost = 23 — decided by the Lean kernel over its whole finite domain, axiom-free64823215-1e97…
  595. 595lean energy.lean: the_cost_per_litre_multiplies_back_to_the_cost — (List.range' 1 20).all (fun l => (splitCost / l) * l ≤ splitCost && splitCost < (splitCost / l + 1) * l) ∧ splitCost / waterOut = 5777 ∧ splitCost / waterOut > roPerLitre * 1000 — decided by the Lean kernel over its whole finite domain, axiom-free2fafc1e2-f58f…
  596. 596lean energy.lean: the_mass_balance_is_the_atom_balance — mgH2 = mass 2 0 ∧ mgO2 = mass 0 2 ∧ mgH2O = mass 2 1 ∧ (List.range' 1 9).all (fun a => (List.range' 1 9).all (fun b => (List.range' 1 9).all (fun c => (a * mass 2 1 == b * mass 2 0 + c * mass 0 2) == balances a b c))) ∧ 2 * mgH2O = 2 * mgH2… — decided by the Lean kernel over its whole finite domain, axiom-free2854e1d5-ab5d…
  597. 597lean energy.lean: the_atom_table_decides_the_balance — (List.range' 1 9).all (fun a => (List.range' 1 9).all (fun b => (List.range' 1 9).all (fun c => (a * atomsH2O.1 == b * atomsH2.1 + c * atomsO2.1 && a * atomsH2O.2 == b * atomsH2.2 + c * atomsO2.2) == balances a b c))) — decided by the Lean kernel over its whole finite domain, axiom-free98e0c98d-7b0c…
  598. 598lean energy.lean: a_part_and_its_rest_read_back_the_whole — (List.range' 1 40).all (fun w => (List.range (w + 1)).all (fun a => per10k a w + per10k (w - a) w ≤ 10000 && 10000 ≤ per10k a w + per10k (w - a) w + 1)) ∧ mgO2 * 100 / (2 * mgH2) = 793 ∧ per10k (2 * mgH2) (2 * mgH2O) = 1119 ∧ per10k mgO2 (2… — decided by the Lean kernel over its whole finite domain, axiom-freed4addfa7-6e96…
  599. 599lean energy.lean: splitting_then_burning_is_the_identity_at_the_ideal — (List.range 1000).all (fun e => burnE (splitE e) == e) ∧ pct burnYield splitCost = 23 — decided by the Lean kernel over its whole finite domain, axiom-freef354845f-b6af…
  600. 600lean energy.lean: the_gas_volume_reads_back_its_moles — (List.range 1000).all (fun m => molesOf (litresOf m) ≤ m && m ≤ molesOf (litresOf m) + 1) ∧ molH2 = 2 * molO2 ∧ litresOf molH2 = 11117 ∧ litresOf molO2 = 5558 ∧ (litresOf molH2 + litresOf molO2) / 9 = 1852 — decided by the Lean kernel over its whole finite domain, axiom-free464b601e-4839…
  601. 601lean energy.lean: two_parts_in_three_is_two_thirds_at_every_scale — (List.range' 1 500).all (fun m => pct (2 * m) (3 * m) == 66) ∧ pct molH2 (molH2 + molO2) = 66 ∧ pct (2 * mgH2) (2 * mgH2O) = 11 — decided by the Lean kernel over its whole finite domain, axiom-free6913b23d-5d6d…
  602. 602lean energy.lean: the_energy_per_litre_multiplies_back_to_the_energy — (List.range' 1 30).all (fun l => (whPerKgH2 * 100 / l) * l ≤ whPerKgH2 * 100 && whPerKgH2 * 100 < (whPerKgH2 * 100 / l + 1) * l) ∧ whPerKgH2 * 100 / litresOf molH2 = 299 ∧ petrolWhL * 100 / 299 = 3244 — decided by the Lean kernel over its whole finite domain, axiom-free6ca259eb-a048…
  603. 603lean energy.lean: compression_scales_the_energy_per_litre_linearly — (List.range 100).all (fun k => 2 * whPerLitreAt k ≤ whPerLitreAt (2 * k) && whPerLitreAt (2 * k) ≤ 2 * whPerLitreAt k + 1) ∧ whPerLitreAt 42 = 1398 ∧ petrolWhL / whPerLitreAt 42 = 6 — decided by the Lean kernel over its whole finite domain, axiom-free62f26437-7387…
  604. 604lean energy.lean: a_ratio_and_its_reciprocal_multiply_back_to_the_whole — (List.range' 1 40).all (fun b => (List.range' 1 b).all (fun a => pct a b * pct b a ≤ 10000 && 10000 < (pct a b + 1) * (pct b a + 1))) ∧ pct splitCost burnYield = 433 ∧ pct burnYield splitCost = 23 ∧ 9 * 1000 / (burnYield / 1000) = 750 — decided by the Lean kernel over its whole finite domain, axiom-free07ef3913-ea46…
  605. 605lean energy.lean: the_loss_and_the_yield_read_back_the_input — (List.range' 1 60).all (fun c => (List.range (c + 1)).all (fun y => (c - y) + y == c && 99 ≤ pct (c - y) c + pct y c && pct (c - y) c + pct y c ≤ 100)) ∧ splitCost - burnYield = 40000 ∧ pct (splitCost - burnYield) splitCost = 76 ∧ pct burnY… — decided by the Lean kernel over its whole finite domain, axiom-free945f6f02-5f28…
  606. 606lean energy.lean: the_residue_ratio_is_the_same_at_every_volume — (List.range' 1 200).all (fun l => residueMg l tdsSeawater == 700 * residueMg l tdsTapWater) ∧ residueMg 100 tdsSeawater / 1000 = 3500 ∧ residueMg 100 tdsTapWater / 1000 = 5 — decided by the Lean kernel over its whole finite domain, axiom-freeb0b19d5b-1924…
  607. 607lean light.lean: the_si_fixes_seven_distinct_nonzero_constants — defining.length = 7 ∧ defining.eraseDups = defining ∧ defining.all (fun x => x > 0) — decided by the Lean kernel over its whole finite domain, axiom-freeb8191727-00d7…
  608. 608lean reach.lean: the_successor_leaves_every_domain_and_the_predecessor_returns — (bounds ++ [largestDomainHere]).all (fun n => n + 1 > n && (n + 1) - 1 == n && (n + 1) % 2 != n % 2) — decided by the Lean kernel over its whole finite domain, axiom-freee11c16ca-5d37…
  609. 609lean speed.lean: the_measured_ratio_exceeds_the_counted_gap — (List.range' 1 20).all (fun k => 2 ^ k / rounds 40 (2 ^ k) ≤ recomputeUs / verifyUs) ∧ (recomputeUs / verifyUs) * verifyUs ≤ recomputeUs ∧ recomputeUs < (recomputeUs / verifyUs + 1) * verifyUs ∧ recomputeUs / verifyUs = 567971 — decided by the Lean kernel over its whole finite domain, axiom-freef8640798-50bd…
  610. 610lean speed.lean: the_verify_in_nanoseconds_reads_back_its_microseconds — (List.range 1000).all (fun u => u * 1000 / 1000 == u) ∧ nsPerVerify = verifyUs * 1000 ∧ nsPerVerify / 1000 = verifyUs ∧ nsPerVerify > 10000 — decided by the Lean kernel over its whole finite domain, axiom-freee8a082ef-9515…
  611. 611lean speed.lean: the_width_is_the_ceiling_of_128_bits_over_the_symbol — (List.range' 1 8).all (fun b => charsFor b * b ≥ 128 && (charsFor b - 1) * b < 128) ∧ charsFor 4 = hexChars ∧ charsFor 6 = hexbitChars ∧ hexbitChars < hexChars ∧ hexbitChars * 100 / hexChars = 68 — decided by the Lean kernel over its whole finite domain, axiom-free5811891a-d052…
  612. 612lean speed.lean: hexbits_are_slower_and_the_ratio_multiplies_back — (List.range' 1 20).all (fun b => (List.range 400).all (fun a => (a / b) * b ≤ a && a < (a / b + 1) * b)) ∧ hexbitMs > hexMs ∧ hexbitMs * 10 / hexMs = 18 — decided by the Lean kernel over its whole finite domain, axiom-free91a92ea5-bedd…
  613. 613lean elementary.lean: the_wythoff_sequences_partition_the_integers — (List.range' 1 50).all (fun m => ((List.range' 1 40).map lowerWythoff).count m + ((List.range' 1 40).map upperWythoff).count m == 1) — decided by the Lean kernel over its whole finite domain, axiom-free45729b78-1ded…
  614. 614lean energy.lean: the_atoms_read_back_from_the_mass — (List.range 10).all (fun h => (List.range 10).all (fun o => atomsOf (mass h o) == some (h, o))) ∧ atomsOf mgH2 = some (2, 0) ∧ atomsOf mgO2 = some (0, 2) ∧ atomsOf mgH2O = some (2, 1) — decided by the Lean kernel over its whole finite domain, axiom-freee49b5ab6-4f44…
  615. 615lean families.lean: invOf_is_an_inverse_and_an_involution_on_the_units — (List.range 9).all (fun d => match invOf d with | some e => d * e % 9 == 1 && invOf e == some d | none => gcd' d 9 != 1) — decided by the Lean kernel over its whole finite domain, axiom-free85ad9b47-1b45…
  616. 616lean families.lean: choose_is_invariant_under_the_involution_k_to_n_minus_k — (List.range 13).all (fun n => (List.range (n + 1)).all (fun k => choose n k == choose n (n - k) && n - (n - k) == k)) — decided by the Lean kernel over its whole finite domain, axiom-free0affa1b0-91a0…
  617. 617lean light.lean: the_second_returns_from_the_metre_and_the_period — (List.range 100).all (fun s => travel s / c == s && periods s / dNuCs == s) — decided by the Lean kernel over its whole finite domain, axiom-free04685db2-fda6…
  618. 618lean z9.lean: the_orbit_step_is_read_back_by_its_log — (List.range 6).all (fun k => logOrbit (orbit k) == some k) ∧ units.all (fun u => (logOrbit u).map orbit == some u) — decided by the Lean kernel over its whole finite domain, axiom-freee29d831e-5bde…
  619. 619lean energy.lean: splitting_then_burning_is_the_identity_at_every_ledger_value — ∀ e : Nat, burnE (splitE e) = e — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts2105157a-992b…
  620. 620lean light.lean: the_second_returns_from_the_metre_and_the_period_at_every_duration — ∀ s : Nat, travel s / c = s ∧ periods s / dNuCs = s — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tse6d8871f-bee4…
  621. 621lean reach.lean: the_predecessor_returns_every_successor — ∀ n : Nat, (n + 1) - 1 = n — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tsa1d55ab6-baca…
  622. 622lean speed.lean: the_microseconds_return_from_the_nanoseconds_at_every_count — ∀ u : Nat, u * 1000 / 1000 = u — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts98899238-b934…
  623. 623lean flow.lean: the_doubling_flow_repeats_every_six_steps — ∀ k : Nat, orbit (k + 6) = orbit k — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tsd5dece46-994f…
  624. 624lean flow.lean: the_doubling_flow_is_its_first_six_steps — ∀ k : Nat, orbit k = orbit (k % 6) — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts38c42166-8f6d…
  625. 625lean flow.lean: navier_stokes_flow_is_bounded_for_every_step — ∀ k : Nat, orbit k < 9 ∧ span.contains (orbit k) = true — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts6dec28f9-502b…
  626. 626lean demand.lean: mantels_bound_is_n_squared_over_four_for_every_n — ∀ n : Nat, (n / 2) * (n - n / 2) = n * n / 4 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tsb9212e56-a3ea…
  627. 627lean demand3.lean: the_euler_characteristic_of_a_genus_g_surface_for_every_g — ∀ g : Nat, chi g + 2 * (g : Int) = 2 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tsa1a899d7-b3c5…
  628. 628lean demand3.lean: a_repunit_has_the_residue_of_its_length_mod_three — ∀ n : Nat, repunit n % 3 = n % 3 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts732113b8-a6d4…
  629. 629lean demand3.lean: a_repunit_is_divisible_by_three_exactly_when_its_length_is_for_every_n — ∀ n : Nat, (repunit n % 3 = 0) ↔ (n % 3 = 0) — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts93c43bd9-4707…
  630. 630lean demand3.lean: repunit_of_a_sum — ∀ n k : Nat, repunit (n + k) = 10 ^ k * repunit n + repunit k — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts5558e77e-438c…
  631. 631lean demand3.lean: repunits_repeat_mod_seven_every_six_digits — ∀ n : Nat, repunit (n + 6) % 7 = repunit n % 7 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tsa67a8eec-997b…
  632. 632lean demand3.lean: a_repunit_has_the_residue_of_its_length_mod_six_mod_seven — ∀ n : Nat, repunit n % 7 = repunit (n % 6) % 7 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tsec5bf7fe-1dd8…
  633. 633lean demand3.lean: a_repunit_is_divisible_by_seven_exactly_when_six_divides_its_length_for_every_n — ∀ n : Nat, (repunit n % 7 = 0) ↔ (n % 6 = 0) — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts2bb98278-186d…
  634. 634lean elementary.lean: the_interior_and_exterior_angles_are_n_straight_angles_for_every_n — ∀ n : Nat, 2 ≤ n → (n - 2) * 180 + 360 = n * 180 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tsd1fbd7f1-d1df…
  635. 635lean elementary.lean: a_product_of_consecutive_numbers_is_even — ∀ n : Nat, n * (n + 1) % 2 = 0 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tscf763033-1ed3…
  636. 636lean elementary.lean: eight_times_a_triangular_number_plus_one_is_an_odd_square_for_every_n — ∀ n : Nat, 8 * (n * (n + 1) / 2) + 1 = (2 * n + 1) * (2 * n + 1) — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts1aa59ef6-880c…
  637. 637lean energy.lean: two_parts_in_three_is_two_thirds_at_every_scale_for_every_m — ∀ m : Nat, 0 < m → pct (2 * m) (3 * m) = 66 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts9177c3d3-8280…
  638. 638lean families.lean: the_powers_of_two_sum_to_one_less_than_the_next_for_every_n — ∀ n : Nat, ((List.range (n + 1)).map (fun i => 2 ^ i)).foldl (· + ·) 0 = 2 ^ (n + 1) - 1 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts3cab57ca-4d36…
  639. 639lean families.lean: square_of_successor — ∀ n : Nat, (n + 1) * (n + 1) = n * n + 2 * n + 1 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tsf9826dc5-b85d…
  640. 640lean families.lean: the_first_n_odd_numbers_sum_to_n_squared_for_every_n — ∀ n : Nat, ((List.range n).map (fun i => 2 * i + 1)).foldl (· + ·) 0 = n * n — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts7baff487-adea…
  641. 641lean mechanical.lean: consecutive_squares_differ_by_the_odd_numbers — ∀ n : Nat, (n + 1) ^ 2 - n * n = 2 * n + 1 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts65131201-9df7…
  642. 642lean mechanical.lean: every_multiple_of_three_four_five_is_pythagorean — ∀ k : Nat, (3 * k) ^ 2 + (4 * k) ^ 2 = (5 * k) ^ 2 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tsa20992d7-56ea…
  643. 643lean mechanical.lean: the_product_of_three_consecutive_numbers_is_even — ∀ n : Nat, n * (n + 1) * (n + 2) % 2 = 0 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts0eb7327f-0789…
  644. 644lean mechanical.lean: the_product_of_three_consecutive_numbers_is_a_multiple_of_three — ∀ n : Nat, n * (n + 1) * (n + 2) % 3 = 0 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tsf3e2ee80-28d1…
  645. 645lean mechanical.lean: the_product_of_any_three_consecutive_integers_is_divisible_by_six_for_every_n — ∀ n : Nat, n * (n + 1) * (n + 2) % 6 = 0 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts65518577-2bc3…
  646. 646lean reversal.lean: foldl_add_start — ∀ (l : List Nat) (a : Nat), l.foldl (· + ·) a = a + l.foldl (· + ·) 0 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts70a7cff5-e668…
  647. 647lean reversal.lean: the_digits_sum_to_the_number_mod_nine_when_the_fuel_covers_them — ∀ f n : Nat, n < 10 ^ f → (digitsF f n).foldl (· + ·) 0 % 9 = n % 9 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts58d4c502-7f73…
  648. 648lean reversal.lean: a_number_is_below_ten_to_its_own_successor — ∀ n : Nat, n < 10 ^ (n + 1) — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tsdc7330c0-7a4c…
  649. 649lean reversal.lean: the_digit_sum_has_the_residue_of_the_number_mod_nine_for_every_n — ∀ n : Nat, digitSum n % 9 = n % 9 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts1a8922c4-c55c…
  650. 650lean reversal.lean: folding_by_ten_keeps_the_residue_of_the_digit_sum — ∀ (l : List Nat) (a : Nat), (l.foldl (fun a d => a * 10 + d) a) % 9 = (a + l.foldl (· + ·) 0) % 9 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tsc7ce0223-8884…
  651. 651lean reversal.lean: reversal_keeps_the_residue_mod_nine_for_every_n — ∀ n : Nat, reverseNum n % 9 = n % 9 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts3159b043-f18c…
  652. 652lean split.lean: the_coin_step_and_the_coins_are_inverse_for_every_c — ∀ c : Nat, 3 * c / 3 = c ∧ (3 * c) % 3 = 0 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts1c1ebe41-4e80…
  653. 653lean mechanical.lean: repeated_doubling_is_the_power_of_two_for_every_k — ∀ k : Nat, dbl k = 2 ^ k — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts71d6eeaa-fd06…
  654. 654lean mechanical.lean: relation_digitroot_is_residue_mod9_for_every_n — ∀ n : Nat, 0 < n → DR n = (n - 1) % 9 + 1 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts22aed33c-e7ff…
  655. 655lean mechanical.lean: the_nine_times_table_always_digital_roots_to_nine_for_every_k — ∀ k : Nat, 0 < k → DR (9 * k) = 9 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts36b3b4ea-25f1…
  656. 656lean mechanical.lean: the_digital_root_has_the_residue_of_its_number — ∀ n : Nat, DR n % 9 = n % 9 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tsefc4383f-1f52…
  657. 657lean mechanical.lean: a_digital_root_lies_between_one_and_nine — ∀ n : Nat, 0 < n → 1 ≤ DR n ∧ DR n ≤ 9 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts298da32e-60d7…
  658. 658lean mechanical.lean: casting_out_nines_is_multiplicative_for_every_a_b — ∀ a b : Nat, DR (a * b) = DR (DR a * DR b) — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts58842a8d-45b2…
  659. 659lean mechanical.lean: the_moduli_dimensions_are_three_g_minus_three_and_six_g_minus_six_for_every_g — ∀ g : Nat, 3 * g - 3 = (6 * g - 6) / 2 ∧ 6 * g - 6 = 2 * (3 * g - 3) — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts633ba212-336a…
  660. 660lean reach.lean: exhaustion_never_reaches_its_own_bound_for_every_n — ∀ n : Nat, (List.range n).length = n ∧ n ∉ List.range n — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tsdfc2849f-3870…
  661. 661lean reach.lean: the_successor_of_every_bound_lies_outside_for_every_n — ∀ n : Nat, n + 1 ∉ List.range n — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts1113761c-4967…
  662. 662lean reach.lean: doubling_the_domain_leaves_the_same_hole_for_every_n — ∀ n : Nat, 2 * n ∉ List.range (2 * n) — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tsf57338c8-104b…
  663. 663lean z9plus.lean: doubling_has_period_six_for_every_k — ∀ k : Nat, pw 2 (k + 6) = pw 2 k — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts2c9ca8bc-08a6…
  664. 664lean z9plus.lean: orbit_digital_roots_have_period_six_for_every_k — ∀ k : Nat, dr (pw 2 (k + 6)) = dr (pw 2 k) — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tse88dfdf8-3c33…
  665. 665lean z9plus.lean: the_doubling_orbit_is_read_from_the_exponent_mod_six — ∀ k : Nat, pw 2 k = pw 2 (k % 6) — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tsc688c966-b59f…
  666. 666lean z9plus.lean: the_orbit_never_meets_the_triad_for_every_k — ∀ k : Nat, pw 2 k ≠ 0 ∧ pw 2 k ≠ 3 ∧ pw 2 k ≠ 6 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts8c3dfc38-91e6…
  667. 667lean z9plus.lean: fibonacci_residues_mod_nine_repeat_every_twenty_four_steps — ∀ k : Nat, fib (k + 24) % 9 = fib k % 9 ∧ fib (k + 25) % 9 = fib (k + 1) % 9 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts04f6a9cd-b19f…
  668. 668lean z9plus.lean: pisano_period_mod_nine_is_twenty_four_for_every_k — ∀ k : Nat, fib9 (k + 24) = fib9 k — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts985c1ebe-dc19…
  669. 669lean z9plus.lean: the_fuelled_gcd_is_the_gcd_when_the_fuel_exceeds_the_second_argument — ∀ f a b : Nat, b < f → gcdF f a b = Nat.gcd a b — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts73c32b16-76ca…
  670. 670lean z9plus.lean: consecutive_fibonacci_numbers_are_coprime — ∀ n : Nat, Nat.gcd (fib n) (fib (n + 1)) = 1 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts5ae6ebcf-4c89…
  671. 671lean z9plus.lean: consecutive_fibonacci_are_coprime_for_every_n — ∀ n : Nat, gcd9 (fib n) (fib (n + 1)) = 1 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts424d4751-1648…
  672. 672lean z9plus.lean: digital_root_agrees_with_the_residue_for_every_n — ∀ n : Nat, 0 < n → (dr n = 9 ↔ m9 n = 0) — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts20da0230-2b9f…
  673. 673lean z9plus.lean: digital_root_is_the_digit_sum_residue_for_every_n — ∀ n : Nat, m9 (digitSum n) = m9 n — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts694fefdf-a71b…
  674. 674lean demand2.lean: the_two_power_sums_are_one_sum — ∀ p n : Nat, sumPow p n = powSum p n — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts6551630b-4917…
  675. 675lean demand2.lean: nicomachus_sum_of_cubes_is_the_square_of_the_triangular_number_for_every_n — ∀ n : Nat, sumPow 3 n = tri n * tri n — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts7aa0bbe0-b4ae…
  676. 676lean demand2.lean: the_sum_of_fifth_powers_has_the_closed_form_for_every_n — ∀ n : Nat, 12 * sumPow 5 n = n * n * (n + 1) * (n + 1) * (2 * n * n + 2 * n - 1) — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts6916652f-bda2…
  677. 677lean elementary.lean: the_lucas_numbers_are_the_sum_of_the_neighbouring_fibonaccis_for_every_n — ∀ n : Nat, lucas (n + 1) = fib n + fib (n + 2) — proved by the Lean kernel for every value (by have), standard axioms only — checked by lean.tscacb33f1-2fc1…
  678. 678lean families.lean: cassinis_identity_for_every_m — ∀ m : Nat, fib (2 * m + 1) * fib (2 * m + 3) = fib (2 * m + 2) * fib (2 * m + 2) + 1 ∧ fib (2 * m) * fib (2 * m + 2) + 1 = fib (2 * m + 1) * fib (2 * m + 1) — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts75a810f1-ae27…
  679. 679lean families.lean: a_sum_over_one_to_n_plus_one_adds_the_last_term — ∀ (g : Nat → Nat) (n : Nat), ((List.range' 1 (n + 1)).map g).foldl (· + ·) 0 = ((List.range' 1 n).map g).foldl (· + ·) 0 + g (n + 1) — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tsf664ca1d-8371…
  680. 680lean families.lean: the_numbers_sum_to_their_closed_form_for_every_n — ∀ n : Nat, 2 * powSum 1 n = n * (n + 1) — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts34fa9fc8-b8ed…
  681. 681lean families.lean: the_squares_sum_to_their_closed_form_for_every_n — ∀ n : Nat, 6 * powSum 2 n = n * (n + 1) * (2 * n + 1) — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts0b7a0569-fb3f…
  682. 682lean families.lean: the_cubes_sum_to_their_closed_form_for_every_n — ∀ n : Nat, 4 * powSum 3 n = n * n * (n + 1) * (n + 1) — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts96b0047e-cf09…
  683. 683lean families.lean: the_fourth_powers_sum_to_their_closed_form_for_every_n — ∀ n : Nat, 30 * powSum 4 n = n * (n + 1) * (2 * n + 1) * (3 * n * n + 3 * n - 1) — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts3419aabd-970f…
  684. 684lean families.lean: the_fifth_powers_sum_to_their_closed_form_for_every_n — ∀ n : Nat, 12 * powSum 5 n = n * n * (n + 1) * (n + 1) * (2 * n * n + 2 * n - 1) — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts790310ea-f06d…
  685. 685lean families.lean: power_sums_match_their_closed_forms_for_every_n — ∀ k n : Nat, 1 ≤ k → k ≤ 5 → powSum k n = faulhaber k n — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts04b04822-598b…
  686. 686lean families.lean: the_sums_of_triangular_numbers_are_the_tetrahedral_numbers_for_every_n — ∀ n : Nat, ((List.range' 1 n).map (fun i => i * (i + 1) / 2)).foldl (· + ·) 0 = n * (n + 1) * (n + 2) / 6 — proved by the Lean kernel for every value (by have), standard axioms only — checked by lean.ts43b9cdd8-7110…
  687. 687lean sequences.lean: cassinis_identity_for_every_m — ∀ m : Nat, fib (2 * m + 1) * fib (2 * m + 3) = fib (2 * m + 2) * fib (2 * m + 2) + 1 ∧ fib (2 * m) * fib (2 * m + 2) + 1 = fib (2 * m + 1) * fib (2 * m + 1) — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts3b815427-42b8…
  688. 688lean nim.lean: the_xor_of_two_bits_is_their_sum_mod_two — ∀ x y : Nat, (if x % 2 == y % 2 then 0 else 1) = (x + y) % 2 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts322304d5-f000…
  689. 689lean nim.lean: xor_commutes_at_every_fuel — ∀ f a b : Nat, xorF f a b = xorF f b a — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tsb091d5a8-4e4a…
  690. 690lean nim.lean: one_more_step_of_fuel_changes_nothing_once_it_exceeds_an_argument — ∀ f a b : Nat, (a < f ∨ b < f) → xorF (f + 1) a b = xorF f a b — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tsadf2ef5a-ef44…
  691. 691lean nim.lean: more_fuel_changes_nothing_once_it_exceeds_an_argument — ∀ k f a b : Nat, (a < f ∨ b < f) → xorF (f + k) a b = xorF f a b — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts961d94be-959c…
  692. 692lean nim.lean: xor_reads_the_same_at_every_sufficient_fuel — ∀ g a b : Nat, (a < g ∨ b < g) → xorN a b = xorF g a b — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tse04a45b5-8834…
  693. 693lean nim.lean: a_number_xored_with_itself_is_zero_at_every_fuel — ∀ f b : Nat, xorF f b b = 0 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts409e78df-b565…
  694. 694lean nim.lean: xor_splits_off_its_lowest_bit — ∀ g x c : Nat, 1 ≤ g → xorF (g + 1) x c = (x + c) % 2 + 2 * xorF g (x / 2) (c / 2) — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tsfa8f797f-95fa…
  695. 695lean nim.lean: xor_undoes_itself_when_the_fuel_suffices — ∀ f a b g : Nat, (a < f ∨ b < f) → b < g → xorF g (xorF f a b) b = a — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tsba799e13-9cb6…
  696. 696lean nim.lean: xor_is_commutative_for_every_a_b — ∀ a b : Nat, xorN a b = xorN b a — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tse62bc467-f90b…
  697. 697lean nim.lean: xor_zero_is_identity_for_every_a — ∀ a : Nat, xorN a 0 = a — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts667bd69d-51ea…
  698. 698lean nim.lean: xor_is_its_own_inverse_for_every_a_b — ∀ a b : Nat, xorN (xorN a b) b = a — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tse2f6d0f1-2fa2…
  699. 699lean nim.lean: xor_is_the_sum_of_the_bits_plus_twice_the_xor_of_the_halves — ∀ a b : Nat, xorN a b = (a + b) % 2 + 2 * xorN (a / 2) (b / 2) — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts07c467d9-8226…
  700. 700lean nim.lean: xor_is_associative_below_every_bound — ∀ n a b c : Nat, a + b + c ≤ n → xorN (xorN a b) c = xorN a (xorN b c) — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts0c3ef805-2811…
  701. 701lean nim.lean: xor_is_associative_for_every_a_b_c — ∀ a b c : Nat, xorN (xorN a b) c = xorN a (xorN b c) — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tsd2a922d9-f09d…
  702. 702lean nim.lean: the_nim_sum_is_a_gf2_vector_addition_for_every_a_b_c — ∀ a b c : Nat, xorN a b = xorN b a ∧ xorN (xorN a b) c = xorN a (xorN b c) ∧ xorN (xorN a b) b = a ∧ xorN a 0 = a — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tscaa5c327-62cf…
  703. 703lean sequences.lean: a_bit_sum_over_one_more_position_adds_that_bit — ∀ F m : Nat, (List.range (F + 1)).foldl (fun a i => a + m / 2 ^ i % 2) 0 = (List.range F).foldl (fun a i => a + m / 2 ^ i % 2) 0 + m / 2 ^ F % 2 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tsf5e71d05-068c…
  704. 704lean sequences.lean: halving_shifts_every_bit_down_by_one — ∀ m i : Nat, m / 2 ^ (i + 1) = m / 2 / 2 ^ i — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tsa5201a6e-8f86…
  705. 705lean sequences.lean: the_bits_of_a_number_are_its_low_bit_then_the_bits_of_its_half — ∀ F m : Nat, (List.range (F + 1)).foldl (fun a i => a + m / 2 ^ i % 2) 0 = m % 2 + (List.range F).foldl (fun a i => a + m / 2 / 2 ^ i % 2) 0 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts2c2dcdbf-8b9f…
  706. 706lean sequences.lean: bits_above_the_number_add_nothing — ∀ k F n : Nat, n < 2 ^ F → (List.range (F + k)).foldl (fun a i => a + n / 2 ^ i % 2) 0 = (List.range F).foldl (fun a i => a + n / 2 ^ i % 2) 0 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts77439845-748b…
  707. 707lean sequences.lean: a_number_is_below_two_to_its_own_power — ∀ n : Nat, n < 2 ^ n — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts4f5a709a-5de5…
  708. 708lean sequences.lean: a_number_is_below_two_to_its_own_successor — ∀ n : Nat, n < 2 ^ (n + 1) — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts586b3088-ac85…
  709. 709lean sequences.lean: doubling_preserves_the_bit_count_for_every_n — ∀ n : Nat, popcount (2 * n) = popcount n — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts7006c6f5-3c8d…
  710. 710lean sequences.lean: the_odd_step_sets_exactly_one_further_bit_for_every_n — ∀ n : Nat, popcount (2 * n + 1) = popcount n + 1 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tsd9da9f38-b47d…
  711. 711lean sequences.lean: thue_morse_doubling_recurrence_for_every_n — ∀ n : Nat, tm (2 * n) = tm n ∧ tm (2 * n + 1) = 1 - tm n — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts50c8ad36-d08a…
  712. 712lean address.lean: the_version_stamp_keeps_the_low_nibble_of_every_byte — ∀ b : Nat, b < 256 → or8 (and8 b 15) 128 = 128 + b % 16 — decided by the Lean kernel over its whole finite domain, axiom-free913d0338-59bc…
  713. 713lean address.lean: the_variant_stamp_keeps_the_low_six_bits_of_every_byte — ∀ b : Nat, b < 256 → or8 (and8 b 63) 128 = 128 + b % 64 — decided by the Lean kernel over its whole finite domain, axiom-freefbc0f2d4-3490…
  714. 714lean address.lean: stamping_twice_is_stamping_once — ∀ b : Nat, b < 256 → or8 (and8 (or8 (and8 b 15) 128) 15) 128 = or8 (and8 b 15) 128 ∧ or8 (and8 (or8 (and8 b 63) 128) 63) 128 = or8 (and8 b 63) 128 — decided by the Lean kernel over its whole finite domain, axiom-freec397ec59-2a56…
  715. 715lean demand3.lean: the_two_coin_fare_is_minus_the_euler_characteristic_at_genus_two — (110 : Int) - 108 = - chi 2 — decided by the Lean kernel over its whole finite domain, axiom-free665800be-8ca8…
  716. 716lean address.lean: the_third_group_is_version_eight_over_twelve_hash_bits — ∀ b6 b7 : Nat, b6 < 256 → b7 < 256 → (or8 (and8 b6 15) 128) * 256 + b7 = 8 * 4096 + (b6 % 16 * 256 + b7) ∧ b6 % 16 * 256 + b7 < 4096 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts136a86a7-b50b…
  717. 717lean address.lean: the_fourth_group_is_variant_two_over_fourteen_hash_bits — ∀ b8 b9 : Nat, b8 < 256 → b9 < 256 → (or8 (and8 b8 63) 128) * 256 + b9 = 2 * 16384 + (b8 % 64 * 256 + b9) ∧ b8 % 64 * 256 + b9 < 16384 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts087841c4-271d…
  718. 718lean fnv.lean: the_split_multiply_is_the_exact_thirty_two_bit_product — ∀ a b : Nat, (a % 65536 * b + a / 65536 * b % 65536 * 65536) % M32 = mul32 a b — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts71d78d5c-0f87…
  719. 719lean energy.lean: the_boundary_is_sharp — mass 5333 0 = mass 0 336 — decided by the Lean kernel over its whole finite domain, axiom-free6237820f-0a7b…
  720. 720lean address.lean: the_unstamped_bits_read_back_from_every_stamped_byte — ∀ b : Nat, b < 256 → and8 (or8 (and8 b 15) 128) 15 = b % 16 ∧ and8 (or8 (and8 b 63) 128) 63 = b % 64 — proved by the Lean kernel for every value (by decide), standard axioms only — checked by lean.ts69a4f3a2-4653…
  721. 721lean address.lean: the_twelve_hash_bits_read_back_from_the_third_group — ∀ b6 b7 : Nat, b6 < 256 → b7 < 256 → ((or8 (and8 b6 15) 128) * 256 + b7) / 4096 = 8 ∧ ((or8 (and8 b6 15) 128) * 256 + b7) % 4096 = b6 % 16 * 256 + b7 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts221f974c-1535…
  722. 722lean address.lean: the_fourteen_hash_bits_read_back_from_the_fourth_group — ∀ b8 b9 : Nat, b8 < 256 → b9 < 256 → ((or8 (and8 b8 63) 128) * 256 + b9) / 16384 = 2 ∧ ((or8 (and8 b8 63) 128) * 256 + b9) % 16384 = b8 % 64 * 256 + b9 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tsedc4013a-9ea0…
  723. 723lean demand.lean: four_times_a_near_product_is_at_most_the_square — ∀ a d : Nat, a * (a + d) * 4 ≤ (a + (a + d)) * (a + (a + d)) — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts61fde2f2-4a84…
  724. 724lean demand.lean: no_cut_beats_the_balanced_one_for_every_n — ∀ n a : Nat, a ≤ n → a * (n - a) ≤ n * n / 4 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tsf87585db-e4be…
  725. 725lean demand2.lean: the_squared_triangular_numbers_difference_back_to_the_cubes_for_every_n — ∀ n : Nat, tri (n + 1) * tri (n + 1) = tri n * tri n + (n + 1) ^ 3 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts76f6ba26-b6dd…
  726. 726lean demand3.lean: the_genus_reads_back_from_chi_for_every_g — ∀ g : Nat, ((2 - chi g) / 2).toNat = g — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tsb2627057-efa5…
  727. 727lean demand3.lean: chi_is_injective_for_every_g_h — ∀ g h : Nat, chi g = chi h → g = h — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts9259ab3c-4bbc…
  728. 728lean demand3.lean: a_repunit_is_below_ten_to_its_length — ∀ k : Nat, repunit k < 10 ^ k — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts63e37ea7-0f19…
  729. 729lean demand3.lean: a_repunit_splits_back_into_its_two_parts_for_every_n_k — ∀ n k : Nat, repunit (n + k) / 10 ^ k = repunit n ∧ repunit (n + k) % 10 ^ k = repunit k — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts56ed7d0a-28d5…
  730. 730lean elementary.lean: the_polygon_side_count_reads_back_from_its_angle_sum — ∀ n : Nat, 2 ≤ n → ((n - 2) * 180 + 360) / 180 = n — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts0ad62680-b148…
  731. 731lean elementary.lean: every_odd_square_one_more_than_eight_times_m_makes_m_triangular — ∀ m r : Nat, 8 * m + 1 = r * r → m = r / 2 * (r / 2 + 1) / 2 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts958b6261-542d…
  732. 732lean elementary.lean: the_fibonaccis_are_a_fifth_of_the_neighbouring_lucas_numbers_for_every_n — ∀ n : Nat, 5 * fib (n + 1) = lucas n + lucas (n + 2) — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts16091996-5977…
  733. 733lean elementary.lean: half_a_product_of_consecutive_numbers_multiplies_back_for_every_n — ∀ n : Nat, n * (n + 1) / 2 * 2 = n * (n + 1) — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tscf74f953-f0e2…
  734. 734lean energy.lean: burning_then_splitting_is_the_identity_above_the_bond — ∀ e : Nat, bondHundredthsKJ ≤ e → splitE (burnE e) = e — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tsfe87a66a-6ac9…
  735. 735lean energy.lean: one_part_in_three_is_a_third_at_every_scale_for_every_m — ∀ m : Nat, 0 < m → pct m (3 * m) = 33 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tsb2c52079-42f3…
  736. 736lean energy.lean: the_gas_volume_reads_back_its_moles_for_every_m — ∀ m : Nat, molesOf (litresOf m) ≤ m ∧ m ≤ molesOf (litresOf m) + 1 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts21c3d846-9c3e…
  737. 737lean energy.lean: the_mass_names_the_molecule_below_5333_hydrogens — ∀ h o h' o' : Nat, h < 5333 → h' < 5333 → mass h o = mass h' o' → h = h' ∧ o = o' — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tsa30f7f70-4bfa…
  738. 738lean energy.lean: a_floor_division_multiplies_back_within_one_divisor — ∀ a l : Nat, 0 < l → a / l * l ≤ a ∧ a < (a / l + 1) * l — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tsc6871639-adb9…
  739. 739lean families.lean: choose_is_invariant_under_the_involution_k_to_n_minus_k_for_every_n — ∀ n k : Nat, k ≤ n → choose n k = choose n (n - k) ∧ n - (n - k) = k — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts6133e3a1-254e…
  740. 740lean families.lean: the_closed_forms_difference_back_to_the_next_power_for_every_n — ∀ k n : Nat, 1 ≤ k → k ≤ 5 → faulhaber k (n + 1) = faulhaber k n + (n + 1) ^ k — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tsb1d34ef3-9b6d…
  741. 741lean families.lean: the_tetrahedral_numbers_difference_back_to_the_triangular_numbers_for_every_n — ∀ n : Nat, (n + 1) * (n + 1 + 1) * (n + 1 + 2) / 6 = n * (n + 1) * (n + 2) / 6 + (n + 1) * (n + 1 + 1) / 2 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tse811a0a1-22b9…
  742. 742lean families.lean: the_powers_of_two_difference_back_to_the_next_power_for_every_n — ∀ n : Nat, (2 ^ (n + 2) - 1) - (2 ^ (n + 1) - 1) = 2 ^ (n + 1) — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts9c202e7c-40cb…
  743. 743lean families.lean: the_odd_numbers_difference_back_to_the_next_odd_number_for_every_n — ∀ n : Nat, ((List.range (n + 1)).map (fun i => 2 * i + 1)).foldl (· + ·) 0 - ((List.range n).map (fun i => 2 * i + 1)).foldl (· + ·) 0 = 2 * n + 1 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts404c2b65-4bb4…
  744. 744lean families.lean: foldl_add_start — ∀ (l : List Nat) (a : Nat), l.foldl (· + ·) a = a + l.foldl (· + ·) 0 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tse29e2887-b564…
  745. 745lean families.lean: the_digits_sum_to_the_number_mod_nine_when_the_fuel_covers_them — ∀ f n : Nat, n < 10 ^ f → (digitsF f n).foldl (· + ·) 0 % 9 = n % 9 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tsbdb7dd00-a595…
  746. 746lean families.lean: a_number_is_below_ten_to_its_own_successor — ∀ n : Nat, n < 10 ^ (n + 1) — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts6021fd10-1371…
  747. 747lean families.lean: the_digit_sum_rules_for_three_and_nine_hold_for_every_n — ∀ n : Nat, (digitSum n % 3 = 0 ↔ n % 3 = 0) ∧ (digitSum n % 9 = 0 ↔ n % 9 = 0) — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tse4b7bd43-9725…
  748. 748lean flow.lean: the_reverse_flow_undoes_every_step — ∀ k : Nat, orbit (k + 1) * 5 % 9 = orbit k — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts8a31d5e4-e83d…
  749. 749lean flow.lean: every_state_of_the_flow_returns_within_six_steps — ∀ k s : Nat, ∃ j, j < 6 ∧ orbit (k + j) = orbit s — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tsfd1cecb4-13df…
  750. 750lean fnv.lean: multiplying_by_the_fnv_prime_is_undone_by_its_inverse_for_every_h — ∀ h : Nat, mul32 (mul32 h FNV_PRIME) 899433627 = h % M32 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts30b021d3-5d2e…
  751. 751lean light.lean: the_metre_returns_from_the_second_for_every_whole_length — ∀ m : Nat, m % c = 0 → travel (m / c) = m — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts01829703-d2a6…
  752. 752lean light.lean: the_period_count_returns_from_the_second_for_every_whole_count — ∀ p : Nat, p % dNuCs = 0 → periods (p / dNuCs) = p — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts917672f5-d4d0…
  753. 753lean mechanical.lean: DR_eq — ∀ n : Nat, DR n = if n = 0 then 0 else 1 + (n - 1) % 9 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tsdec26379-71e5…
  754. 754lean mechanical.lean: halving_undoes_every_doubling_step_for_every_k — ∀ k : Nat, dbl (k + 1) / 2 = dbl k — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts7ac609a7-0ed5…
  755. 755lean mechanical.lean: casting_out_nines_is_additive_for_every_a_b — ∀ a b : Nat, DR (a + b) = DR (DR a + DR b) — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tsf63b1a76-759a…
  756. 756lean mechanical.lean: the_digital_root_fixes_exactly_one_to_nine — ∀ d : Nat, 1 ≤ d → d ≤ 9 → DR d = d — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts7f66abca-14de…
  757. 757lean mechanical.lean: the_digital_root_is_idempotent_for_every_n — ∀ n : Nat, DR (DR n) = DR n — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tscc3d43b3-c3ea…
  758. 758lean mechanical.lean: a_digital_root_of_nine_means_a_multiple_of_nine_for_every_n — ∀ n : Nat, 0 < n → DR n = 9 → n % 9 = 0 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts48527c27-d129…
  759. 759lean mechanical.lean: the_hypotenuse_reads_back_from_every_three_four_five_multiple — ∀ k c : Nat, (3 * k) ^ 2 + (4 * k) ^ 2 = c ^ 2 → c = 5 * k — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts38ab856f-2051…
  760. 760lean mechanical.lean: the_sixth_of_three_consecutive_integers_multiplies_back_for_every_n — ∀ n : Nat, n * (n + 1) * (n + 2) / 6 * 6 = n * (n + 1) * (n + 2) — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts23e7c1bf-1835…
  761. 761lean nim.lean: a_number_xored_with_itself_is_zero_for_every_a — ∀ a : Nat, xorN a a = 0 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts4eb0eb7c-9115…
  762. 762lean nim.lean: xor_is_zero_only_on_equal_arguments_for_every_a_b — ∀ a b : Nat, xorN a b = 0 ↔ a = b — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tsc117a38f-0ab9…
  763. 763lean nim.lean: the_halves_and_the_low_bit_read_back_from_the_xor_for_every_a_b — ∀ a b : Nat, xorN a b / 2 = xorN (a / 2) (b / 2) ∧ xorN a b % 2 = (a + b) % 2 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tsc526ac9a-e469…
  764. 764lean reach.lean: the_successor_returns_every_positive_predecessor — ∀ n : Nat, 0 < n → (n - 1) + 1 = n — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts23e0a041-8135…
  765. 765lean reach.lean: exhaustion_reaches_everything_below_its_bound_for_every_n — ∀ n k : Nat, k < n → k ∈ List.range n — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tsca669c32-5df9…
  766. 766lean reach.lean: the_predecessor_of_every_positive_bound_lies_inside — ∀ n : Nat, 0 < n → n - 1 ∈ List.range n — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts9f5d69b8-d238…
  767. 767lean reach.lean: halving_the_domain_keeps_the_half_inside_for_every_n — ∀ n : Nat, 0 < n → n ∈ List.range (2 * n) — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tsbe05a537-ee2d…
  768. 768lean reversal.lean: digitsF_zero — ∀ f : Nat, digitsF f 0 = [] — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tse37e7ee7-d6b6…
  769. 769lean reversal.lean: every_digit_is_below_ten — ∀ f n : Nat, ∀ d ∈ digitsF f n, d < 10 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts45e2714e-6f2d…
  770. 770lean reversal.lean: the_digits_rebuild_the_number_when_the_fuel_covers_them — ∀ f n : Nat, n < 10 ^ f → (digitsF f n).foldr (fun d a => a * 10 + d) 0 = n — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts06a08633-fb89…
  771. 771lean reversal.lean: the_number_is_rebuilt_from_its_digits_for_every_n — ∀ n : Nat, (digits n).foldr (fun d a => a * 10 + d) 0 = n — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tscbb228e9-06c9…
  772. 772lean reversal.lean: a_sum_is_the_same_read_backwards — ∀ (l : List Nat), l.reverse.foldl (· + ·) 0 = l.foldl (· + ·) 0 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts1b350dab-b05b…
  773. 773lean reversal.lean: the_top_digit_is_nonzero — ∀ f n : Nat, 0 < n → n < 10 ^ f → ∃ L b, digitsF f n = L ++ [b] ∧ 0 < b ∧ b < 10 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tsda813af5-c2e3…
  774. 774lean reversal.lean: reversal_leaves_no_trailing_zero — ∀ n : Nat, 0 < n → 0 < reverseNum n ∧ reverseNum n % 10 ≠ 0 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tsedae203a-46d3…
  775. 775lean reversal.lean: reading_a_list_back_from_the_top — ∀ r : List Nat, r ≠ [] → (∀ d ∈ r, d < 10) → r.reverse.head? ≠ some 0 → 0 < r.reverse.foldl (fun a d => a * 10 + d) 0 ∧ r.length ≤ r.reverse.foldl (fun a d => a * 10 + d) 0 ∧ ∀ f, r.length ≤ f → digitsF f (r.reverse.foldl (fun a d => a * 10… — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tsac35a0e6-3280…
  776. 776lean reversal.lean: the_digits_of_the_reversal_are_the_reversed_digits — ∀ n : Nat, n % 10 ≠ 0 → digits (reverseNum n) = (digitsF (n + 1) n).reverse ∧ digits n = digitsF (n + 1) n — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts91c9f620-0c4f…
  777. 777lean reversal.lean: reversal_is_involutive_off_the_trailing_zeros_for_every_n — ∀ n : Nat, n % 10 ≠ 0 → reverseNum (reverseNum n) = n — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts6ea99113-8427…
  778. 778lean reversal.lean: reversal_is_involutive_exactly_off_the_trailing_zeros_for_every_n — ∀ n : Nat, 0 < n → (reverseNum (reverseNum n) = n ↔ n % 10 ≠ 0) — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts4861172d-e203…
  779. 779lean reversal.lean: more_fuel_changes_no_digit — ∀ f n k : Nat, n < 10 ^ f → digitsF (f + k) n = digitsF f n — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts6dcd0667-a81f…
  780. 780lean reversal.lean: a_trailing_zero_is_a_leading_zero_of_the_digits — ∀ m : Nat, 0 < m → digits (10 * m) = 0 :: digits m — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tsc8aa36fc-ef29…
  781. 781lean reversal.lean: reversal_preserves_the_digit_sum_for_every_n — ∀ n : Nat, digitSum (reverseNum n) = digitSum n — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tsab260836-a2cf…
  782. 782lean reversal.lean: the_fixed_points_of_reversal_are_the_palindromes_for_every_n — ∀ n : Nat, n % 10 ≠ 0 → (reverseNum n = n ↔ (digits n).reverse = digits n) — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts6b0761d8-d62a…
  783. 783lean sequences.lean: halving_removes_exactly_the_low_bit_for_every_n — ∀ n : Nat, popcount n = n % 2 + popcount (n / 2) — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts977069d5-f1b5…
  784. 784lean sequences.lean: the_thue_morse_halving_recurrence_for_every_n — ∀ n : Nat, tm n = (n % 2 + tm (n / 2)) % 2 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts864ba163-a3f8…
  785. 785lean sequences.lean: doubling_shifts_every_bit_up_by_one — ∀ m i : Nat, 2 * m / 2 ^ (i + 1) = m / 2 ^ i — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tsc6f05e84-b232…
  786. 786lean sequences.lean: the_residue_below_the_next_power_adds_one_bit — ∀ m F : Nat, m % 2 ^ (F + 1) = m % 2 ^ F + m / 2 ^ F % 2 * 2 ^ F — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts2607d9ae-7836…
  787. 787lean sequences.lean: the_low_bits_rebuild_the_number_below_every_power — ∀ F m : Nat, (List.range F).foldl (fun a i => a + m / 2 ^ i % 2 * 2 ^ i) 0 = m % 2 ^ F — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tsc79eff54-9841…
  788. 788lean sequences.lean: the_number_is_rebuilt_from_its_bits_for_every_n — ∀ n : Nat, (List.range (n + 1)).foldl (fun a i => a + n / 2 ^ i % 2 * 2 ^ i) 0 = n — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts4e6421ba-ab59…
  789. 789lean speed.lean: the_nanoseconds_return_from_the_microseconds_at_every_whole_count — ∀ n : Nat, n % 1000 = 0 → n / 1000 * 1000 = n — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts7e0b39fe-b643…
  790. 790lean split.lean: the_coins_return_from_the_coin_step_for_every_multiple_of_three — ∀ t : Nat, t % 3 = 0 → 3 * (t / 3) = t — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts0a785a11-be04…
  791. 791lean split.lean: paying_and_refunding_round_trips_for_every_count — ∀ n k : Nat, k ≤ n → 3 * (n - k) + 3 * k = 3 * n — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts31ce2f16-8ab7…
  792. 792lean z9.lean: orbit_repeats_every_six — ∀ k : Nat, orbit (k + 6) = orbit k — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts1d6bb6c2-2c76…
  793. 793lean z9.lean: orbit_is_its_exponent_mod_six — ∀ k : Nat, orbit k = orbit (k % 6) — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tsaf2bb754-dd58…
  794. 794lean z9.lean: the_orbit_step_is_read_back_by_its_log_for_every_k — ∀ k : Nat, logOrbit (orbit k) = some (k % 6) — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tsb806a941-659e…
  795. 795lean z9plus.lean: halving_undoes_doubling_at_every_step — ∀ k : Nat, m9 (pw 2 k * pw 5 k) = 1 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts87e5a9d4-3319…
  796. 796lean z9plus.lean: halving_has_period_six_for_every_k — ∀ k : Nat, pw 5 (k + 6) = pw 5 k — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tsd07f608f-90d3…
  797. 797lean z9plus.lean: halving_orbit_digital_roots_have_period_six_for_every_k — ∀ k : Nat, dr (pw 5 (k + 6)) = dr (pw 5 k) — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts147581f3-c75f…
  798. 798lean z9plus.lean: the_reflected_orbit_meets_the_triad_exactly_at_one_four_seven_for_every_k — ∀ k : Nat, [3, 6, 9].contains (refl (pw 2 k)) = [1, 4, 7].contains (pw 2 k) — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts20cda95a-c30a…
  799. 799lean z9plus.lean: reversal_cannot_change_the_digital_root_for_every_n — ∀ n : Nat, dr (reverseNum n) = dr n — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts43332821-10bc…
  800. 800lean flow.lean: a_ring_sum_splits_over_a_sum — ∀ (f g : Nat → Int) (n : Nat), ringSum (fun i => f i + g i) n = ringSum f n + ringSum g n — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tsdef0f698-6e8c…
  801. 801lean flow.lean: a_ring_sum_of_negatives_is_the_negated_sum — ∀ (f : Nat → Int) (n : Nat), ringSum (fun i => - f i) n = - ringSum f n — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts86a56512-64df…
  802. 802lean flow.lean: ring_sums_agree_where_their_terms_agree — ∀ (f g : Nat → Int) (n : Nat), (∀ i, i < n → f i = g i) → ringSum f n = ringSum g n — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts233f29d5-6b29…
  803. 803lean flow.lean: a_ring_sum_peels_its_first_term — ∀ (f : Nat → Int) (n : Nat), ringSum f (n + 1) = f 0 + ringSum (fun i => f (i + 1)) n — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts4b3735a1-b114…
  804. 804lean flow.lean: a_cyclic_sum_is_unchanged_by_one_step_of_rotation — ∀ (N : Nat) (f : Nat → Int), 0 < N → ringSum (fun i => f (ringNext N i)) N = ringSum f N — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tsd6a6e517-ae76…
  805. 805lean flow.lean: the_site_before_the_next_is_the_site — ∀ N i : Nat, i < N → ringPrev N (ringNext N i) = i — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tse200c2f1-8c10…
  806. 806lean flow.lean: a_bond_sum_reads_the_same_from_either_end — ∀ (N : Nat) (F : Nat → Nat → Int), 0 < N → ringSum (fun i => F (ringPrev N i) i) N = ringSum (fun i => F i (ringNext N i)) N — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts9920e848-6b06…
  807. 807lean flow.lean: the_skew_symmetric_burgers_term_does_no_work_on_every_ring — ∀ (N : Nat) (u : Nat → Int), 0 < N → ringSum (fun i => u i * burgersSkew3 N u i) N = 0 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tsa2e54b88-8b2f…
  808. 808lean flow.lean: the_discrete_laplacian_dissipates_exactly_the_squared_differences — ∀ (N : Nat) (u : Nat → Int), 0 < N → ringSum (fun i => u i * ringLap N u i) N = - ringSum (fun i => (u (ringNext N i) - u i) * (u (ringNext N i) - u i)) N — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.ts289b45b9-0cbe…
  809. 809lean flow.lean: a_sum_of_squares_is_never_negative — ∀ (f : Nat → Int) (n : Nat), 0 ≤ ringSum (fun i => f i * f i) n — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tsb5817e6d-005d…
  810. 810lean flow.lean: the_discrete_energy_never_increases_on_every_ring — ∀ (N : Nat) (u : Nat → Int) (ν : Int), 0 < N → 0 ≤ ν → ringSum (fun i => u i * (3 * ν * ringLap N u i - burgersSkew3 N u i)) N ≤ 0 — proved by the Lean kernel for every value (by intro), standard axioms only — checked by lean.tsd25bc6d6-19e4…
  811. 811lean merkle.lean: the_alteration_reaches_every_position — (List.range 4).all (fun i => setAt [A, B, C, D] i E != [A, B, C, D]) — decided by the Lean kernel over its whole finite domain, axiom-free302ce1bd-f8b6…
  812. 812lean merkle.lean: altering_any_single_leaf_changes_the_root — (List.range 4).all (fun i => merkleFold (setAt [A, B, C, D] i E) != merkleFold [A, B, C, D]) — decided by the Lean kernel over its whole finite domain, axiom-freeb37b91cf-2814…
  813. 813lean instruments.lean: the_strict_order_is_what_is_admitted — precedes (some 4) (some 5) = true ∧ precedes (some 5) (some 5) = false ∧ precedes (some 6) (some 5) = false — decided by the Lean kernel over its whole finite domain, axiom-free49563441-c8b2…
  814. 814lean instruments.lean: admission_is_exactly_the_strict_order — (List.range 12).all (fun a => (List.range 12).all (fun b => precedes (some a) (some b) == decide (a < b))) — decided by the Lean kernel over its whole finite domain, axiom-freef7339fcf-5fd1…
  815. 815lean instruments.lean: an_unknown_instant_is_never_admitted — (List.range 12).all (fun t => precedes none (some t) == false && precedes (some t) none == false) ∧ precedes none none = false — decided by the Lean kernel over its whole finite domain, axiom-free30a5fe9f-75c8…
  816. 816lean instruments.lean: the_boundary_refuses_more_than_it_admits — let cases := (List.range 8).map (fun a => precedes (some a) (some 4)) cases.count true = 4 ∧ cases.count false = 4 — decided by the Lean kernel over its whole finite domain, axiom-freeff7be975-04d9…
  817. 817lean instruments.lean: a_hole_is_an_absence_with_a_later_presence — holes [true, false, true, true] = [1] ∧ tail [true, false, true, true] = [] — decided by the Lean kernel over its whole finite domain, axiom-freef12656ea-a1e0…
  818. 818lean instruments.lean: a_stale_tail_is_an_absence_with_nothing_after_it — tail [true, true, false, false] = [2, 3] ∧ holes [true, true, false, false] = [] — decided by the Lean kernel over its whole finite domain, axiom-freecc70ab36-892f…
  819. 819lean instruments.lean: the_two_causes_occur_together_and_stay_apart — holes [true, false, true, false] = [1] ∧ tail [true, false, true, false] = [3] — decided by the Lean kernel over its whole finite domain, axiom-freec113b614-9502…
  820. 820lean instruments.lean: nothing_built_is_all_tail_and_no_hole — holes [false, false, false] = [] ∧ tail [false, false, false] = [0, 1, 2] ∧ lastPresent [false, false, false] = none — decided by the Lean kernel over its whole finite domain, axiom-free321515e0-bff1…
  821. 821lean instruments.lean: everything_built_accuses_nobody — holes [true, true, true] = [] ∧ tail [true, true, true] = [] — decided by the Lean kernel over its whole finite domain, axiom-free4c08c00c-bcf3…
  822. 822lean instruments.lean: the_pattern_generator_is_complete — (bits 5).length = 32 ∧ (bits 3).length = 8 ∧ ((bits 3).eraseDups).length = 8 — decided by the Lean kernel over its whole finite domain, axiom-free4b497ae9-79db…
  823. 823lean instruments.lean: every_absence_is_charged_to_exactly_one_cause — ((bits 1) ++ (bits 2) ++ (bits 3) ++ (bits 4) ++ (bits 5)).all (fun l => let h := holes l let t := tail l let missing := (idx l).filterMap (fun p => if !p.2 then some p.1 else none) (h.all (fun x => !(t.contains x))) && ((h ++ t).length == … — decided by the Lean kernel over its whole finite domain, axiom-free2b9f9c07-50f9…
  824. 824lean instruments.lean: an_echo_carries_the_signal_only_until_it_is_subtracted — contains echoed SITE = true ∧ contains (clip echoed) SITE = false — decided by the Lean kernel over its whole finite domain, axiom-free3208d0ac-7913…
  825. 825lean instruments.lean: the_page_s_own_words_survive_the_subtraction — contains genuine SITE = true ∧ contains (clip genuine) SITE = true — decided by the Lean kernel over its whole finite domain, axiom-freeb071539d-99e9…
  826. 826lean instruments.lean: every_copy_of_the_witness_is_removed — contains (clip twice) SITE = false — decided by the Lean kernel over its whole finite domain, axiom-free430a5a37-1627…
  827. 827lean instruments.lean: subtracting_twice_is_subtracting_once — clip (clip echoed) = clip echoed ∧ clip (clip genuine) = clip genuine — decided by the Lean kernel over its whole finite domain, axiom-freebec39268-0840…
  828. 828lean instruments.lean: an_empty_witness_removes_nothing — unreflect genuine.length [] genuine = genuine ∧ unreflect echoed.length [] echoed = echoed — decided by the Lean kernel over its whole finite domain, axiom-freeda283ead-c144…
  829. 829lean instruments.lean: text_without_the_witness_is_untouched — clip SITE = SITE ∧ clip [60, 112, 62] = [60, 112, 62] — decided by the Lean kernel over its whole finite domain, axiom-free113a3e4a-e3d5…
  830. 830lean asymmetric.lean: a_signature_is_four_uuids_and_a_key_is_two — signatureBytes = 4 * uuidBytes ∧ publicKeyBytes = 2 * uuidBytes — decided by the Lean kernel over its whole finite domain, axiom-free78459e31-65a2…
  831. 831lean asymmetric.lean: neither_the_key_nor_the_signature_fits_in_a_uuid — uuidBytes < publicKeyBytes ∧ uuidBytes < signatureBytes ∧ uuidBytes * 8 < signatureBytes * 8 — decided by the Lean kernel over its whole finite domain, axiom-freeb4fa9d0f-ece5…
  832. 832lean asymmetric.lean: not_even_the_whole_uuid_would_hold_one — uuidBytes * 8 = 128 ∧ signatureBytes * 8 = 512 ∧ 128 < 512 — decided by the Lean kernel over its whole finite domain, axiom-free2e3ba4c9-f281…
  833. 833lean asymmetric.lean: what_travels_beside_the_identifier — publicKeyBytes + signatureBytes = 96 ∧ 96 = 6 * uuidBytes — decided by the Lean kernel over its whole finite domain, axiom-free00ac5e64-215d…
  834. 834lean asymmetric.lean: the_check_cannot_separate_the_payloads — 2 ^ checkBits < 2 ^ payloadBits ∧ payloadBits = 90 ∧ checkBits = 32 — decided by the Lean kernel over its whole finite domain, axiom-freedf641661-41c4…
  835. 835lean asymmetric.lean: the_gap_is_fifty_eight_bits — payloadBits - checkBits = 58 ∧ 2 ^ payloadBits = 2 ^ 58 * 2 ^ checkBits — decided by the Lean kernel over its whole finite domain, axiom-freea0740c1c-cc73…
  836. 836lean asymmetric.lean: a_checksum_is_the_same_whoever_computes_it — (List.range 6).all (fun s => (List.range 6).all (fun t => (List.range 12).all (fun p => checkOf s p == checkOf t p))) — decided by the Lean kernel over its whole finite domain, axiom-free38a9023c-ed6d…
  837. 837lean asymmetric.lean: two_secrets_part_company_on_every_payload — (List.range 12).all (fun p => tagOf 1 p != tagOf 2 p) ∧ ¬ ((List.range 6).all (fun s => (List.range 6).all (fun t => (List.range 12).all (fun p => tagOf s p == tagOf t p)))) — decided by the Lean kernel over its whole finite domain, axiom-free61826d5e-d6b7…
  838. 838lean asymmetric.lean: the_tag_moves_with_the_payload — (List.range 11).all (fun p => tagOf 1 p != tagOf 1 (p + 1)) — decided by the Lean kernel over its whole finite domain, axiom-free2c10db8a-11f2…
  839. 839lean program.lean: the_program_field_is_forty_two_bits_not_forty_eight — programF.length = 42 ∧ ((List.range 48).map (· + 32)).length = 48 — decided by the Lean kernel over its whole finite domain, axiom-free9f6fb2bb-27a6…
  840. 840lean program.lean: the_three_fields_and_the_reserved_six_are_the_whole_uuid — checkF.length + programF.length + messageF.length + RESERVED.length = 128 — decided by the Lean kernel over its whole finite domain, axiom-freeed6043cd-3b33…
  841. 841lean program.lean: the_widths_are_what_the_layout_says — checkF.length = 32 ∧ messageF.length = 48 ∧ RESERVED.length = 6 — decided by the Lean kernel over its whole finite domain, axiom-free47c47e33-a9a0…
  842. 842lean program.lean: every_reserved_bit_is_in_the_middle_group — RESERVED.all (fun r => 32 ≤ r && r < 80) — decided by the Lean kernel over its whole finite domain, axiom-free8e8e33c0-1383…
  843. 843lean program.lean: neither_the_check_nor_the_message_gives_up_a_bit — (checkF.all (fun i => !(RESERVED.contains i))) ∧ (messageF.all (fun i => !(RESERVED.contains i))) — decided by the Lean kernel over its whole finite domain, axiom-freea7b062c6-ab2f…
  844. 844lean program.lean: every_position_belongs_to_exactly_one_field — (List.range 128).all (fun i => inExactlyOne i == 1) — decided by the Lean kernel over its whole finite domain, axiom-free68c1c3ef-b289…
  845. 845lean program.lean: nothing_outside_the_uuid_is_claimed — (List.range' 128 32).all (fun i => inExactlyOne i == 0) — decided by the Lean kernel over its whole finite domain, axiom-freec58dcc5c-bb67…
  846. 846lean program.lean: each_field_is_ascending_and_repeats_nothing — ascending checkF ∧ ascending programF ∧ ascending messageF — decided by the Lean kernel over its whole finite domain, axiom-freedd9f31cc-fd90…
  847. 847lean program.lean: the_check_is_the_deposit_s_own_fnv — hash32 0 (List.replicate 12 0) = 1661287312 — decided by the Lean kernel over its whole finite domain, axiom-freef5fafbe0-1997…
  848. 848lean program.lean: the_payload_outruns_the_check — 2 ^ 32 < 2 ^ (42 + 48) ∧ 42 + 48 = 90 — decided by the Lean kernel over its whole finite domain, axiom-free78f23d08-e771…
  849. 849lean program.lean: no_map_from_four_onto_three_separates_them_all — maps3.all (fun f => decide ((f.eraseDups).length < 4)) — decided by the Lean kernel over its whole finite domain, axiom-free3f50ffb1-28f6…
  850. 850lean program.lean: four_values_can_be_separated_by_four — maps4.any (fun f => decide ((f.eraseDups).length == 4)) — decided by the Lean kernel over its whole finite domain, axiom-free5a28096c-369c…
  851. 851lean asymmetric.lean: the_square_root_rule_is_the_one_this_prime_admits — p % 8 = 5 ∧ (p + 3) % 8 = 0 ∧ p % 4 = 1 ∧ p % 4 ≠ 3 — decided by the Lean kernel over its whole finite domain, axiom-freeb2d4dab4-6281…
  852. 852lean asymmetric.lean: the_cofactor_is_bracketed_at_eight — 4 * L < p ∧ p < 8 * L ∧ L < p — decided by the Lean kernel over its whole finite domain, axiom-freea882288a-1ac0…
  853. 853lean rays.lean: the_orbit_is_the_six_units — orbit 6 1 = [3, 2, 6, 4, 5, 1] ∧ (orbit 6 1).length = 6 — decided by the Lean kernel over its whole finite domain, axiom-freed625db75-2feb…
  854. 854lean rays.lean: the_order_visits_every_ray_exactly_once — vortexOrder.length = 7 ∧ (vortexOrder.eraseDups).length = 7 ∧ (List.range 7).all (fun i => vortexOrder.contains i) — decided by the Lean kernel over its whole finite domain, axiom-free51ce4368-821c…
  855. 855lean rays.lean: the_reversed_order_is_also_a_permutation — vortexReversed.length = 7 ∧ (vortexReversed.eraseDups).length = 7 ∧ (List.range 7).all (fun i => vortexReversed.contains i) — decided by the Lean kernel over its whole finite domain, axiom-freecfd8d572-6ff9…
  856. 856lean rays.lean: the_two_senses_are_not_the_same_walk — vortexOrder ≠ vortexReversed ∧ vortexOrder.head? = vortexReversed.head? — decided by the Lean kernel over its whole finite domain, axiom-freeccac8571-dd1d…
  857. 857lean rays.lean: reversing_the_sense_twice_is_the_identity — (0 :: ((vortexReversed.tail).reverse)) = vortexOrder — decided by the Lean kernel over its whole finite domain, axiom-free92578972-73dd…
  858. 858lean rays.lean: inverting_twice_is_the_identity — ((List.range 40).map (fun n => invert (invert (lowBits [n, n + 1, n + 2])) == lowBits [n, n + 1, n + 2])).all id — decided by the Lean kernel over its whole finite domain, axiom-free69b33021-cafb…
  859. 859lean rays.lean: a_trace_and_its_inversion_agree_nowhere — (List.range 40).all (fun n => let t := lowBits [n, n + 1, n + 2, n + 3] (List.range 4).all (fun i => (t.getD i 0) + ((invert t).getD i 0) == 1)) — decided by the Lean kernel over its whole finite domain, axiom-freecface271-a819…
  860. 860lean rays.lean: the_low_bit_sees_what_the_residue_cannot — (0 % 9 == 9 % 9) ∧ (0 % 9 == 18 % 9) ∧ ¬ (0 % 2 == 9 % 2) — decided by the Lean kernel over its whole finite domain, axiom-freef21dc8c1-025d…
  861. 861lean rays.lean: the_two_by_seven_reads_more_than_the_seven — DIMENSIONS = 14 ∧ DIGITS_READ = 28 ∧ 2 * N = 14 ∧ DIGITS_READ > 2 * N — decided by the Lean kernel over its whole finite domain, axiom-free2181ea1e-20b3…
  862. 862lean rays.lean: four_digits_stay_unread_and_are_counted — DIGITS_TOTAL - DIGITS_READ = 4 ∧ DIGITS_READ < DIGITS_TOTAL — decided by the Lean kernel over its whole finite domain, axiom-freecfdf098a-f7a8…
  863. 863lean rays.lean: the_wrap_is_what_makes_it_a_torus — d1 0 8 = 1 ∧ d1 8 0 = 1 ∧ d1 0 4 = 4 ∧ d1 4 0 = 4 — decided by the Lean kernel over its whole finite domain, axiom-free85e8c4fa-30b9…
  864. 864lean rays.lean: the_distance_is_symmetric_and_zero_only_on_itself — (List.range 9).all (fun a => (List.range 9).all (fun b => (d1 a b == d1 b a) && ((d1 a b == 0) == (a == b)))) — decided by the Lean kernel over its whole finite domain, axiom-free4eae84a8-ac4c…
  865. 865lean rays.lean: the_triangle_inequality_holds_on_every_triple — (List.range 9).all (fun a => (List.range 9).all (fun b => (List.range 9).all (fun c => decide (d1 a c ≤ d1 a b + d1 b c)))) — decided by the Lean kernel over its whole finite domain, axiom-free5f6fe76f-c6ea…
  866. 866lean instruments.lean: any_negator_before_the_claim_refuses_it — refused [7, 2, 9] 5 = true ∧ refused [7, 9] 5 = false ∧ refused [5] 5 = false — decided by the Lean kernel over its whole finite domain, axiom-free61753440-c6c1…
  867. 867lean instruments.lean: the_window_is_monotone_in_the_claim_s_position — (List.range 10).all (fun c => (List.range 10).all (fun d => if c ≤ d then (!(refused [3] c) || refused [3] d) else true)) — decided by the Lean kernel over its whole finite domain, axiom-free223bfc2c-f60b…
  868. 868lean instruments.lean: with_no_negator_nothing_is_cleared — (List.range 10).all (fun c => refused [] c == false) — decided by the Lean kernel over its whole finite domain, axiom-freefdba66f0-240b…
  869. 869lean program.lean: the_fields_read_back_exactly — readField programF (encodeBits P0 M0) = P0 ∧ readField messageF (encodeBits P0 M0) = M0 ∧ readField programF (encodeBits P1 M1) = P1 ∧ readField messageF (encodeBits P1 M1) = M1 — decided by the Lean kernel over its whole finite domain, axiom-freecdf3c4f3-4c16…
  870. 870lean program.lean: the_check_field_carries_the_check — readField checkF (encodeBits P0 M0) = checkBits P0 M0 — decided by the Lean kernel over its whole finite domain, axiom-freef2c56146-946d…
  871. 871lean program.lean: the_reserved_six_survive_any_payload — [(P0, M0), (P1, M1), (P0, M1), (P1, M0), (PZ, MZ)].all (fun pm => let b := encodeBits pm.1 pm.2 (b.getD 48 false == true) && (b.getD 49 false == false) && (b.getD 50 false == false) && (b.getD 51 false == false) && (b.getD 64 false == true)… — decided by the Lean kernel over its whole finite domain, axiom-free33b79421-00e4…
  872. 872lean program.lean: the_flip_reaches_every_payload_position — (List.range 42).all (fun i => flipAt P0 i != P0) ∧ (List.range 48).all (fun i => flipAt M0 i != M0) — decided by the Lean kernel over its whole finite domain, axiom-freebbcc9872-ae56…
  873. 873lean program.lean: flipping_any_program_bit_moves_the_check — (List.range 42).all (fun i => checkBits (flipAt P0 i) M0 != checkBits P0 M0) — decided by the Lean kernel over its whole finite domain, axiom-free457871fb-d7a0…
  874. 874lean program.lean: flipping_any_message_bit_moves_the_check — (List.range 48).all (fun i => checkBits P0 (flipAt M0 i) != checkBits P0 M0) — decided by the Lean kernel over its whole finite domain, axiom-free131cee6e-62a3…
  875. 875lean program.lean: an_untouched_container_reads_intact — [(P0, M0), (P1, M1), (PZ, MZ)].all (fun pm => intact (encodeBits pm.1 pm.2)) — decided by the Lean kernel over its whole finite domain, axiom-free24e09b9f-fa04…
  876. 876lean program.lean: a_damaged_container_is_refused_at_every_program_position — (List.range 42).all (fun i => !(intact (flipBit (encodeBits P0 M0) (programF.getD i 0)))) — decided by the Lean kernel over its whole finite domain, axiom-free4cb0515d-b4c1…
  877. 877lean program.lean: the_reserved_six_are_where_the_rendering_puts_them — RESERVED = [48, 49, 50, 51, 64, 65] ∧ byteAt 2 = 6 ∧ byteAt 3 = 8 ∧ byteAt 4 = 10 — decided by the Lean kernel over its whole finite domain, axiom-free4d490971-9f9a…
  878. 878lean roots.lean: the_cube_root_is_the_floor — iroot 3 (2 * 2 ^ 192) ^ 3 <= 2 * 2 ^ 192 — decided by the Lean kernel over its whole finite domain, axiom-free60dc4761-9a49…
  879. 879lean roots.lean: the_cube_root_is_not_one_short — 2 * 2 ^ 192 < (iroot 3 (2 * 2 ^ 192) + 1) ^ 3 — decided by the Lean kernel over its whole finite domain, axiom-free80fe22fd-a510…
  880. 880lean roots.lean: the_square_root_is_the_floor_and_not_one_short — iroot 2 (2 * 2 ^ 128) ^ 2 <= 2 * 2 ^ 128 ∧ 2 * 2 ^ 128 < (iroot 2 (2 * 2 ^ 128) + 1) ^ 2 — decided by the Lean kernel over its whole finite domain, axiom-free73292676-fefa…
  881. 881lean roots.lean: the_prime_generator_is_complete — firstPrimes 40 8 = [2, 3, 5, 7, 11, 13, 17, 19] ∧ (firstPrimes 40 8).all isPrime ∧ ((List.range' 2 18).filter isPrime).length = 8 — decided by the Lean kernel over its whole finite domain, axiom-free999c4094-b5b6…
  882. 882lean roots.lean: the_first_round_constant_is_that_cube_root_fraction — frac64 3 2 = 0x428a2f98d728ae22 — decided by the Lean kernel over its whole finite domain, axiom-freee464678b-2899…
  883. 883lean roots.lean: the_first_initial_value_is_that_square_root_fraction — frac64 2 2 = 0x6a09e667f3bcc908 — decided by the Lean kernel over its whole finite domain, axiom-freee9398daf-fd28…
  884. 884lean roots.lean: the_cube_and_the_square_do_not_agree — frac64 3 2 != frac64 2 2 ∧ frac64 3 3 != frac64 2 3 — decided by the Lean kernel over its whole finite domain, axiom-free28cb8c6b-7c2c…
  885. 885lean imprint.lean: the_free_region_is_a_hundred_and_twenty_two — FREE.length = 122 ∧ RESERVED.length = 6 ∧ FREE.length + RESERVED.length = 128 — decided by the Lean kernel over its whole finite domain, axiom-free82c2c108-cf5f…
  886. 886lean imprint.lean: the_capacity_is_the_free_region_less_the_header — CAPACITY = 115 ∧ CAPACITY + LEN_BITS = FREE.length — decided by the Lean kernel over its whole finite domain, axiom-free05ee2cb9-0963…
  887. 887lean imprint.lean: no_reserved_bit_is_free — RESERVED.all (fun r => !(FREE.contains r)) — decided by the Lean kernel over its whole finite domain, axiom-freedddd46cc-3c26…
  888. 888lean imprint.lean: seven_bits_count_past_the_capacity — 2 ^ LEN_BITS > CAPACITY ∧ 2 ^ (LEN_BITS - 1) < CAPACITY — decided by the Lean kernel over its whole finite domain, axiom-free9c0e2abe-7301…
  889. 889lean imprint.lean: every_short_message_comes_back — (List.range 9).all (fun n => decodeBits (encodeBits (alt n)) == alt n) — decided by the Lean kernel over its whole finite domain, axiom-free5d24f33c-b06b…
  890. 890lean imprint.lean: the_all_set_message_comes_back_too — (List.range 9).all (fun n => decodeBits (encodeBits (ones n)) == ones n) — decided by the Lean kernel over its whole finite domain, axiom-freec6ae9fbf-82c8…
  891. 891lean imprint.lean: the_header_records_the_length — (List.range 9).all (fun n => natOf ((FREE.map (fun i => (encodeBits (alt n)).getD i false)).take LEN_BITS) == n) — decided by the Lean kernel over its whole finite domain, axiom-freead8567b8-120e…
  892. 892lean imprint.lean: a_shorter_message_is_not_a_longer_one — encodeBits (alt 3) != encodeBits (alt 4) ∧ encodeBits (ones 0) != encodeBits (ones 1) — decided by the Lean kernel over its whole finite domain, axiom-free7c00d44d-8834…
  893. 893lean imprint.lean: the_reserved_six_survive_any_message — [alt 0, alt 5, ones 8, alt 115].all (fun m => let b := encodeBits m (b.getD 48 false == true) && (b.getD 49 false == false) && (b.getD 50 false == false) && (b.getD 51 false == false) && (b.getD 64 false == true) && (b.getD 65 false == fals… — decided by the Lean kernel over its whole finite domain, axiom-free12a83c85-7690…
  894. 894lean index.lean: the_tens_complement_is_an_involution_with_one_fixed_point — (List.range 10).all (fun d => refl (refl d) == d) ∧ ((List.range 10).filter (fun d => refl d == d)).length = 1 — decided by the Lean kernel over its whole finite domain, axiom-freee9dd9619-515b…
  895. 895lean index.lean: each_unit_has_exactly_one_inverse_and_each_non_unit_none — (List.range 9).all (fun d => ((List.range 9).filter (fun e => (d * e) % 9 == 1)).length == (if isUnit d then 1 else 0)) — decided by the Lean kernel over its whole finite domain, axiom-free661bba08-39e9…
  896. 896lean index.lean: the_doubling_orbit_stays_in_the_ring_for_forty_eight_steps — ((List.range 48).map orbit).all (fun v => v < 9) ∧ (List.range 48).all (fun k => span.contains (orbit k)) — decided by the Lean kernel over its whole finite domain, axiom-free98c5c4b5-949a…
  897. 897lean index.lean: the_doubling_orbit_first_returns_to_one_at_six — (List.range 6).all (fun k => k == 0 || orbit k != 1) ∧ orbit 6 == 1 — decided by the Lean kernel over its whole finite domain, axiom-free996a80a9-10d3…
  898. 898lean index.lean: the_span_is_exactly_the_units_of_the_ring — (List.range 9).all (fun d => span.contains d == isUnit d) ∧ (List.range 9).all (fun d => isUnit d || ! span.contains d) — decided by the Lean kernel over its whole finite domain, axiom-free2d45299e-ed42…
  899. 899lean index.lean: the_span_and_the_units_both_sum_to_zero_mod_nine — (span.foldr (· + ·) 0) % 9 == 0 ∧ ((List.range 9).filter isUnit).foldr (· + ·) 0 % 9 == 0 — decided by the Lean kernel over its whole finite domain, axiom-freea6bd7475-788f…
  900. 900lean index.lean: the_orbit_is_one_closed_loop_of_six_distinct_points — orbit 6 == orbit 0 ∧ (List.range 6).all (fun i => (List.range 6).all (fun j => (orbit i == orbit j) == (i == j))) — decided by the Lean kernel over its whole finite domain, axiom-free10ad046c-32e7…
  901. 901lean theology.lean: the_mirror_and_the_doubling_agree_at_no_residue — (List.range 9).all (fun d => refl (dbl d) % 9 != (2 * refl d) % 9) ∧ ((List.range 9).filter (fun d => refl (dbl d) % 9 == (2 * refl d) % 9)).length = 0 — decided by the Lean kernel over its whole finite domain, axiom-free28708e4a-fe0f…
  902. 902lean theology.lean: confirming_a_witness_is_uniform_while_finding_one_is_not — ((List.range 9).filter isUnit).all (fun d => (d * invOf d) % 9 == 1) ∧ (((List.range 9).filter isUnit).map searchCost).eraseDups.length > 1 ∧ ((List.range 9).filter isUnit).any (fun d => searchCost d > searchCost 1) — decided by the Lean kernel over its whole finite domain, axiom-free2241453d-2a19…
  903. 903lean theology.lean: no_start_ever_crosses_between_the_units_and_the_non_units — (List.range 9).all (fun s => (List.range 48).all (fun k => isUnit (iter k s) == isUnit s)) — decided by the Lean kernel over its whole finite domain, axiom-free0582fb57-6ae9…
  904. 904lean theology.lean: the_origin_is_reached_at_every_step_exactly_by_the_origin — (List.range 9).all (fun s => (List.range 48).all (fun k => (iter k s == 0) == (s == 0))) — decided by the Lean kernel over its whole finite domain, axiom-freeb31744a1-62f3…
  905. 905lean theology.lean: generating_the_same_set_is_exactly_being_of_the_same_kind — (List.range 9).all (fun g => (List.range 9).all (fun h => sameSet (spanOf g) (spanOf h) == ((isUnit g == isUnit h) && ((g == 0) == (h == 0))))) — decided by the Lean kernel over its whole finite domain, axiom-freec5a06c7c-8c41…
  906. 906lean theology.lean: the_orbit_is_antipodal_and_each_opposite_pair_sums_to_nine — (List.range 3).all (fun i => orbit i + orbit (i + 3) == 9) ∧ (span.foldr (· + ·) 0) % 9 == 0 — decided by the Lean kernel over its whole finite domain, axiom-freedceecba8-5d64…
  907. 907lean theology.lean: the_orbit_has_no_doubling_closed_part_but_nothing_and_itself — (List.range 64).all (fun m => let s := subsetOf m (! s.all (fun v => s.contains (dbl v))) || s.length == 0 || s.length == span.length) ∧ span.all (fun v => span.contains (dbl v)) — decided by the Lean kernel over its whole finite domain, axiom-free412804db-ea5f…
  908. 908lean theology.lean: the_pairing_is_one_ordering_of_seven_out_of_all_of_them — pairing.eraseDups.length = 7 ∧ (List.range 7).all (fun i => pairing.contains i) ∧ pairing.length = (List.range 7).length ∧ fact pairing.length = 5040 — decided by the Lean kernel over its whole finite domain, axiom-free4db1d76e-da5a…
  909. 909lean instruments.lean: a_path_dirty_before_the_run_is_never_attributed_to_it — (List.range 16).all (fun a => (List.range 16).all (fun b => (List.range 16).all (fun t => (mine (setOf a) (setOf b) (setOf t)).all (fun p => ! (setOf a).contains p)))) — decided by the Lean kernel over its whole finite domain, axiom-free8652f875-b425…
  910. 910lean instruments.lean: an_untracked_path_is_never_attributed — (List.range 16).all (fun a => (List.range 16).all (fun b => (List.range 16).all (fun t => (mine (setOf a) (setOf b) (setOf t)).all (fun p => (setOf t).contains p)))) — decided by the Lean kernel over its whole finite domain, axiom-freed3932ec5-4ae8…
  911. 911lean instruments.lean: nothing_is_attributed_that_is_not_dirty_afterwards — (List.range 16).all (fun a => (List.range 16).all (fun b => (List.range 16).all (fun t => subset (mine (setOf a) (setOf b) (setOf t)) (setOf b)))) — decided by the Lean kernel over its whole finite domain, axiom-free2419d78b-a4c4…
  912. 912lean instruments.lean: a_wider_record_of_what_was_dirty_attributes_no_more — (List.range 16).all (fun a => (List.range 16).all (fun a' => (List.range 16).all (fun b => ! subset (setOf a) (setOf a') || subset (mine (setOf a') (setOf b) paths) (mine (setOf a) (setOf b) paths)))) — decided by the Lean kernel over its whole finite domain, axiom-freef530a405-14d0…
  913. 913lean instruments.lean: a_change_made_by_another_hand_during_the_run_is_charged_to_the_run — (List.range 16).any (fun a => (List.range 16).any (fun b => paths.any (fun p => ! (setOf a).contains p && (setOf b).contains p && (mine (setOf a) (setOf b) paths).contains p))) — decided by the Lean kernel over its whole finite domain, axiom-free90355aa7-fd8b…
  914. 914lean instruments.lean: a_run_that_changes_nothing_attributes_nothing — (List.range 16).all (fun a => (List.range 16).all (fun t => mine (setOf a) (setOf a) (setOf t) == [])) — decided by the Lean kernel over its whole finite domain, axiom-free1c832cbd-2887…
  915. 915lean instruments.lean: reverting_once_leaves_nothing_further_to_attribute — (List.range 16).all (fun a => (List.range 16).all (fun b => (List.range 16).all (fun t => let m := mine (setOf a) (setOf b) (setOf t) mine (setOf a) ((setOf b).filter (fun p => ! m.contains p)) (setOf t) == []))) — decided by the Lean kernel over its whole finite domain, axiom-free4426c91f-28f6…
  916. 916lean instruments.lean: the_reverted_and_the_untouched_partition_what_is_dirty — (List.range 16).all (fun a => (List.range 16).all (fun b => let m := mine (setOf a) (setOf b) paths let rest := (setOf b).filter (fun p => ! m.contains p) m.all (fun p => ! rest.contains p) && (setOf b).all (fun p => m.contains p || rest.co… — decided by the Lean kernel over its whole finite domain, axiom-free9fda16c2-ca54…
  917. 917lean nucleus.lean: every_capacity_is_even — caps.all (fun c => c % 2 == 0) — decided by the Lean kernel over its whole finite domain, axiom-freef2d535a0-1bf8…
  918. 918lean nucleus.lean: the_seven_marked_prefixes_take_the_published_values — closures = [2, 8, 20, 28, 50, 82, 126] — decided by the Lean kernel over its whole finite domain, axiom-free91efa07e-77cd…
  919. 919lean nucleus.lean: each_of_the_seven_is_reached_exactly_once_among_all_prefixes — closures.all (fun m => (prefixes.filter (fun p => p == m)).length == 1) — decided by the Lean kernel over its whole finite domain, axiom-free65a430c2-6e73…
  920. 920lean nucleus.lean: the_capacities_sum_to_the_last_of_the_seven — total caps = 126 ∧ total caps = closures.foldr (fun a b => max a b) 0 — decided by the Lean kernel over its whole finite domain, axiom-freeec4d7a37-fa3b…
  921. 921lean nucleus.lean: the_seven_increase_strictly — (List.range (closures.length - 1)).all (fun i => closures.getD i 0 < closures.getD (i + 1) 0) — decided by the Lean kernel over its whole finite domain, axiom-freed3355931-131e…
  922. 922lean nucleus.lean: the_seal_multiplies_back_to_one — product numerators = product denominators — decided by the Lean kernel over its whole finite domain, axiom-freeaedef66f-0f69…
  923. 923lean nucleus.lean: the_fit_is_an_exact_integer_identity — 108 * 17 = 1836 — decided by the Lean kernel over its whole finite domain, axiom-free7c33b6d2-060d…
  924. 924lean nucleus.lean: the_fit_is_not_the_measured_ratio — 1836 * 10000 ≠ 18361527 — decided by the Lean kernel over its whole finite domain, axiom-free3e5b63c7-5ca0…
  925. 925lean authority.lean: nothing_withdrawn_is_live — withdrawn.all (fun k => ! live.contains k) ∧ live.all (fun k => ! withdrawn.contains k) — decided by the Lean kernel over its whole finite domain, axiom-free504b6638-5a8f…
  926. 926lean authority.lean: every_sealed_statement_is_live_or_withdrawn_and_not_both — sealed.all (fun k => (live.contains k || withdrawn.contains k) && ! (live.contains k && withdrawn.contains k)) — decided by the Lean kernel over its whole finite domain, axiom-freef797d801-3e74…
  927. 927lean authority.lean: withdrawing_shrinks_the_live_set_and_never_the_record — live.length + withdrawn.length = sealed.length ∧ withdrawn.all (fun k => sealed.contains k) — decided by the Lean kernel over its whole finite domain, axiom-freed2b796e8-29d1…
  928. 928lean authority.lean: a_rider_and_a_verdict_are_different_things — (carriesRider.any (fun k => ! isVerdict.contains k)) ∧ (isVerdict.any (fun k => ! carriesRider.contains k)) ∧ (carriesRider.any (fun k => isVerdict.contains k)) — decided by the Lean kernel over its whole finite domain, axiom-free71fe6459-9e87…
  929. 929lean authority.lean: withdrawing_never_raises_the_frozen_count — (List.range 256).all (fun m => let taken := bits m let after := carriesRider.filter (fun k => ! taken.contains k) after.length ≤ carriesRider.length) — decided by the Lean kernel over its whole finite domain, axiom-free1aac6788-923f…
  930. 930lean authority.lean: clearing_changes_no_seal — cleared.all (fun k => sealed.contains k) ∧ (sealed.filter (fun k => ! cleared.contains k)).length + cleared.length = sealed.length — decided by the Lean kernel over its whole finite domain, axiom-free7bd9776a-18f2…
  931. 931lean authority.lean: a_cleared_statement_leaves_the_queue_and_stays_on_the_record — (isVerdict.filter (fun k => ! cleared.contains k)).all (fun k => sealed.contains k) ∧ (isVerdict.filter (fun k => ! cleared.contains k)).length ≤ isVerdict.length — decided by the Lean kernel over its whole finite domain, axiom-freea357fd68-31d0…
  932. 932lean authority.lean: refusing_every_verdict_never_refuses_the_whole_record — isVerdict.all (fun k => sealed.contains k) ∧ sealed.any (fun k => ! isVerdict.contains k) ∧ isVerdict.length < sealed.length — decided by the Lean kernel over its whole finite domain, axiom-free6e853633-d7fe…
  933. 933lean planck.lean: the_three_planck_units_share_one_relative_uncertainty — ppm ellP ellPUnc = 11 ∧ ppm tP tPUnc = 11 ∧ ppm mP mPUnc = 11 — decided by the Lean kernel over its whole finite domain, axiom-free55140311-eb5c…
  934. 934lean planck.lean: the_square_root_halves_what_is_known_about_the_measured_constant — 2 * ppm ellP ellPUnc = ppm bigG bigGUnc ∧ 2 * ppm tP tPUnc = ppm bigG bigGUnc ∧ 2 * ppm mP mPUnc = ppm bigG bigGUnc — decided by the Lean kernel over its whole finite domain, axiom-freeb8782530-4860…
  935. 935lean planck.lean: the_measurement_admits_thirty_seven_values_and_not_one — window.length = 37 ∧ window.head? = some (ellP - ellPUnc) ∧ window.getLast? = some (ellP + ellPUnc) — decided by the Lean kernel over its whole finite domain, axiom-freede29e184-4c40…
  936. 936lean planck.lean: the_digital_root_tracks_the_unit_and_not_the_scale — dr ellP = 8 ∧ dr tP = 4 ∧ dr mP = 9 ∧ dr ellP ≠ dr tP ∧ dr tP ≠ dr mP — decided by the Lean kernel over its whole finite domain, axiom-freee53500b7-2ac3…
  937. 937lean planck.lean: the_orbit_holds_two_thirds_of_the_ring_so_landing_on_it_says_little — orbit.length = 6 ∧ axis.length = 3 ∧ orbit.length + axis.length = 9 ∧ orbit.contains (dr ellP) ∧ orbit.contains (dr tP) ∧ axis.contains (dr mP) — decided by the Lean kernel over its whole finite domain, axiom-freeef62fe1e-e10c…
  938. 938lean planck.lean: no_product_of_three_lattice_constants_lands_where_the_planck_length_is — products.length = 2197 ∧ products.all (fun v => v < ellP - ellPUnc || v > ellP + ellPUnc) — decided by the Lean kernel over its whole finite domain, axiom-free9a16e510-2ed2…
  939. 939lean planck.lean: the_same_search_does_reach_the_magnitude — (products.filter (fun v => 1600000 ≤ v && v ≤ 1700000)).length = 9 — decided by the Lean kernel over its whole finite domain, axiom-freeeb57a919-a1ee…
  940. 940lean planck.lean: a_search_expecting_less_than_one_hit_settles_nothing_either_way — 9 * (2 * ellPUnc + 1) / 100001 = 0 ∧ 9 * (2 * ellPUnc + 1) < 100001 — decided by the Lean kernel over its whole finite domain, axiom-free10ecab4b-c2be…
  941. 941lean planck.lean: every_planck_unit_is_a_square_root_and_not_a_plain_product — dimEllP.1 % 2 ≠ 0 ∧ dimTP.1 % 2 ≠ 0 ∧ dimMP.1 % 2 ≠ 0 — decided by the Lean kernel over its whole finite domain, axiom-free089656ee-28f2…
  942. 942lean planck.lean: length_over_time_cancels_both_and_leaves_the_defined_constant — ddiv dimEllP dimTP = (0, 0, 2) — decided by the Lean kernel over its whole finite domain, axiom-freec47bf818-f597…
  943. 943lean planck.lean: length_times_mass_cancels_gravity_and_leaves_the_quantum — dmul dimEllP dimMP = (2, 0, -2) — decided by the Lean kernel over its whole finite domain, axiom-free16811f4a-d0ee…
  944. 944lean planck.lean: length_over_mass_cancels_the_quantum_and_leaves_gravity — ddiv dimEllP dimMP = (0, 2, -4) — decided by the Lean kernel over its whole finite domain, axiom-free8c098abf-9aa3…
  945. 945lean planck.lean: the_gravitational_exponent_predicts_every_published_uncertainty — gPpm dimEllP = 11 ∧ gPpm dimTP = 11 ∧ gPpm dimMP = 11 ∧ gPpm (ddiv dimEllP dimTP) = 0 ∧ gPpm (dmul dimEllP dimMP) = 0 ∧ gPpm (ddiv dimEllP dimMP) = ppm bigG bigGUnc — decided by the Lean kernel over its whole finite domain, axiom-free53bf0add-fed9…
  946. 946lean planck.lean: the_three_uncertainties_are_one_uncertainty_wearing_three_faces — (ddiv dimEllP dimTP).2.1 = 0 ∧ (dmul dimEllP dimMP).2.1 = 0 ∧ (ddiv dimEllP dimMP).2.1 ≠ 0 — decided by the Lean kernel over its whole finite domain, axiom-free9879b17b-0c42…
  947. 947lean planck.lean: the_published_digits_miss_an_identity_that_has_no_measurement_in_it — ratioFromDigits = 299792422 ∧ ratioFromDigits ≠ cDefined ∧ cDefined - ratioFromDigits = 36 — decided by the Lean kernel over its whole finite domain, axiom-freed9c40976-6f84…
  948. 948lean planck.lean: the_miss_is_rounding_and_sits_far_below_the_uncertainty — (cDefined - ratioFromDigits) * 1000000 < 11 * cDefined ∧ 11 * cDefined / ((cDefined - ratioFromDigits) * 1000000) = 91 — decided by the Lean kernel over its whole finite domain, axiom-freee0719e22-4940…
  949. 949lean planck.lean: not_one_value_the_world_admits_is_reachable_from_this_lattice — window.all (fun v => ! reachable v) — decided by the Lean kernel over its whole finite domain, axiom-free7ff9784c-dea6…
  950. 950lean planck.lean: every_seed_factors_over_those_primes_so_every_product_does — seeds.all (fun s => reachable s) — decided by the Lean kernel over its whole finite domain, axiom-free2bb01390-5215…
  951. 951lean planck.lean: the_exponent_predicts_the_registry_with_a_literal_on_neither_side — gPpm dimEllP = ppm ellP ellPUnc ∧ gPpm dimTP = ppm tP tPUnc ∧ gPpm dimMP = ppm mP mPUnc — decided by the Lean kernel over its whole finite domain, axiom-free9f8f686c-bb89…
  952. 952lean planck.lean: the_exact_halving_survives_only_because_the_division_truncated — ppm4 ellP ellPUnc = 111368 ∧ ppm4 bigG bigGUnc = 224742 ∧ 2 * ppm4 ellP ellPUnc ≠ ppm4 bigG bigGUnc — decided by the Lean kernel over its whole finite domain, axiom-free927f3553-ab6d…
  953. 953lean planck.lean: no_power_of_ten_moves_the_root — (List.range 8).all (fun k => dr (ellP * 10 ^ k) = dr ellP) — decided by the Lean kernel over its whole finite domain, axiom-free5247f951-6e3b…
  954. 954lean planck.lean: an_exactly_defined_non_decimal_unit_moves_the_root — ellPInches = 63632086614 ∧ dr ellPInches = 9 ∧ dr ellPInches ≠ dr ellP — decided by the Lean kernel over its whole finite domain, axiom-free1c80d362-10a2…
  955. 955lean planck.lean: the_miss_fits_inside_the_printed_precision_and_not_inside_the_measurement — displayBudget = 120 ∧ cDefined - ratioFromDigits ≤ displayBudget ∧ displayBudget * 10000 < 11 * cDefined — decided by the Lean kernel over its whole finite domain, axiom-free261b31f7-51a9…
  956. 956lean planck.lean: the_planck_mantissa_factors_outside_the_lattice — ellP = 5 * 323251 ∧ (List.range' 2 568).all (fun d => 323251 % d ≠ 0) ∧ ! reachable ellP — decided by the Lean kernel over its whole finite domain, axiom-freea8b669c6-e11d…
  957. 957lean handle.lean: the_four_hex_field_round_trips_over_its_whole_space — (List.range 16).all (fun a => (List.range 16).all (fun b => (List.range 16).all (fun c => (List.range 16).all (fun d => let n := fromNibs a b c d nib n 0 == a && nib n 1 == b && nib n 2 == c && nib n 3 == d && n < 65536)))) — decided by the Lean kernel over its whole finite domain, axiom-freea2d36cba-f5e8…
  958. 958lean handle.lean: the_field_runs_from_zero_to_its_last_value — fromNibs 0 0 0 0 = 0 ∧ fromNibs 15 15 15 15 = 65535 ∧ (List.range 16).all (fun d => fromNibs 0 0 0 d == 4096 * d) — decided by the Lean kernel over its whole finite domain, axiom-free7714e0a9-e35c…
  959. 959lean handle.lean: a_uuid_is_thirty_two_hex_and_exactly_three_groups_are_four_wide — groups.foldl (· + ·) 0 = 32 ∧ (groups.filter (fun g => g == 4)).length = 3 ∧ groups.length = 5 — decided by the Lean kernel over its whole finite domain, axiom-freea998790f-3068…
  960. 960lean handle.lean: the_address_space_is_finite_so_enough_messages_must_share_an_address — space = 16 ^ 4 ∧ space = 2 ^ 16 ∧ ((List.range 17).map (fun m => m % 16)).eraseDups.length < 17 — decided by the Lean kernel over its whole finite domain, axiom-free1d85c5d8-e141…
  961. 961lean handle.lean: one_address_two_messages_and_the_handle_is_what_tells_them_apart — addr 3 = addr 19 ∧ under 0 3 = under 0 19 ∧ under 0 3 ≠ under 1 19 — decided by the Lean kernel over its whole finite domain, axiom-free1b3ee59d-ca46…
  962. 962lean handle.lean: the_same_message_at_two_positions_never_seals_alike — (List.range 32).all (fun m => (List.range 8).all (fun i => (List.range 8).all (fun j => i == j || sealAt m i != sealAt m j))) — decided by the Lean kernel over its whole finite domain, axiom-free606fefb8-c2ab…
  963. 963lean handle.lean: reordering_the_handles_always_moves_the_fifth — (perms.map (fun p => fold4 (p.get! 0) (p.get! 1) (p.get! 2) (p.get! 3))).eraseDups.length = 24 — decided by the Lean kernel over its whole finite domain, axiom-free0509ef1a-9b13…
  964. 964lean handle.lean: an_address_never_determines_the_message_it_addresses — (List.range 16).all (fun a => 1 < ((List.range 64).filter (fun m => addr m == a)).length) — decided by the Lean kernel over its whole finite domain, axiom-free147d6591-a70a…
  965. 965lean light.lean: the_molar_gas_constant_is_an_exact_product_of_two_defined_constants — molarGas = 831446261815324 — decided by the Lean kernel over its whole finite domain, axiom-free8b8f7b5c-e29c…
  966. 966lean light.lean: the_faraday_constant_is_an_exact_product_of_two_defined_constants — faraday = 964853321233100184 — decided by the Lean kernel over its whole finite domain, axiom-freece0f984b-550e…
  967. 967lean planck.lean: length_times_mass_meets_the_quantum_in_the_digits — missPpb quantumLhs quantumRhs = 171 — decided by the Lean kernel over its whole finite domain, axiom-free5da05fbd-34e5…
  968. 968lean planck.lean: length_over_mass_meets_gravity_in_the_digits — missPpb gravityLhs gravityRhs = 142 — decided by the Lean kernel over its whole finite domain, axiom-free9c98e0ea-4fdb…
  969. 969lean planck.lean: the_relations_cannot_express_the_uncertainty_they_inherit — missPpb quantumLhs quantumRhs > missPpb gravityLhs gravityRhs ∧ missPpb gravityLhs gravityRhs * 1000 < ppm bigG bigGUnc * 1000000 ∧ gPpm dimMP = 11 ∧ gPpm (dmul dimEllP dimMP) = 0 — decided by the Lean kernel over its whole finite domain, axiom-free9e420848-d43d…
Captain's message:https://uuidna.com/captain/message — free on the free sailing angle; prize earning in waves — contribute 2 to earn up to 64 per wave, keep the rest (the two coins per commercial use; the seal is 128 bits = 64 two-bit fold-verifications, O(log N)). Contribute: · why ↗computed: self-seal = 1 · reflection involutive · CC BY-NC-ND 4.0License: CC BY-NC-ND 4.0 — free for non-commercial use (attribution Tsvetan Rouschev); commercial = the two coins (110 − 108 = 2 = −χ genus-2) · ceccec@psg.bgLicensing formula: free for public interest and independent research, unless commercial · commercial = the measured bits saved (O(N) − O(1)), the two coins (2 = 110 − 108 = −χ genus-2) the conserved invariant · verified green by receipts · integrity, not truthThis referrer perspective: 0df9d0cb-66d2-808b-87d3-577ebf14a809Public URLs (content-addressed):https://uuidna.org 8ef35f1f-38f3…https://uuidna.com 58cfb4c9-e262…https://ceccec.psg.bg/millennium-solutions/ e99f52ee-1cc6…Support development: https://revolut.me/ceccec