{ "made": "2026-10-30T05:03:35.091Z", "rungs": [ "The floor: proven math", "Quarks", "Atoms", "Cells", "People", "Worlds", "Stars", "Galaxies", "The observable universe" ], "counts": { "lean": 167, "checker": 0, "upgraded": 49 }, "facts": [ { "id": "root", "rung": 0, "star": true, "claim": "Daniel's Root Theorem: fixing a mistake once, at the root, never costs more than fixing its copies in every layer above it, and costs strictly less once it has spread to two or more layers", "answer": "c ≤ n × c, and c < n × c when n ≥ 2 and c > 0", "how": "lean", "theorem": "DanielRootTheorem", "proof": "Lean theorem DanielRootTheorem, by Daniel Steadham, 2026; it rests only on Lean's standard axioms. It is the reason this site checks at the root." }, { "id": "founder", "rung": 0, "claim": "Daniel's Founder's Claim: if, every week, the library of proven facts grows at least as much as the cost of finding a new one, its lead never shrinks; if it grows strictly more, the lead grows every week", "answer": "facts − cost never falls when Δfacts ≥ Δcost each week, and strictly rises when Δfacts > Δcost", "how": "lean", "theorem": "DanielFounderClaim", "proof": "Lean theorem DanielFounderClaim, by Daniel Steadham, 2026 (LeanProofs/Founder.lean); it rests only on Lean's standard axioms, no sorry.", "notProven": "Lean proves the \"if, then\". Whether the library really grows faster than its cost is measured week by week, and the first verdict is due 2026-11-08." }, { "id": "pvsnp-check", "rung": 0, "claim": "P vs NP, the easy half: checking a proposed answer to any SAT puzzle (Boolean rules over switches) is fast and right, so SAT is in NP", "answer": "the checker says yes exactly when every rule is met, in at most one step per switch mention and per rule, plus one", "how": "lean", "theorem": "PvsNP.sat_check_is_fast_and_right", "proof": "Lean theorem PvsNP.sat_check_is_fast_and_right (LeanProofs/PvsNP.lean); it rests only on Lean's standard axioms, no sorry. A planted false version (one step too few) was refused.", "notProven": "This is the known, easy half: checking. Whether finding an answer can always be as fast as checking one is P vs NP itself, and it stays OPEN." }, { "id": "p01", "rung": 4, "claim": "Dice odds: sum of two dice is 7", "answer": "1/6", "how": "lean", "theorem": "p01_dice_sum_seven", "proof": "Lean theorem p01_dice_sum_seven, replayed by Lean's kernel and accepted by a second, separately written checker (nanoda); it rests only on Lean's standard axioms." }, { "id": "p02", "rung": 4, "claim": "Coin streaks: a run of 5 heads in 20 flips", "answer": "32751/131072", "how": "lean", "theorem": "p02_coin_streaks", "proof": "Lean theorem p02_coin_streaks, replayed by Lean's kernel and accepted by a second, separately written checker (nanoda); it rests only on Lean's standard axioms." }, { "id": "p04", "rung": 4, "claim": "Card draws: exactly two aces in five cards", "answer": "2162/54145", "how": "lean", "theorem": "CheapLane.p04_two_aces_in_five", "proof": "Lean theorem CheapLane.p04_two_aces_in_five, replayed by Lean's kernel and accepted by a second, separately written checker (nanoda); it rests only on Lean's standard axioms." }, { "id": "p05", "rung": 4, "claim": "Birthday problem: a shared birthday among 23 people", "answer": "1 - (365*364*363*...*343)/365^23", "how": "lean", "theorem": "TowerBatch.p05_birthday_problem", "proof": "Lean theorem TowerBatch.p05_birthday_problem, replayed by Lean's kernel and accepted by a second, separately written checker (nanoda); it rests only on Lean's standard axioms." }, { "id": "p06", "rung": 4, "claim": "Random walk: return to origin after 20 steps", "answer": "46189/262144", "how": "lean", "theorem": "p06_random_walk", "proof": "Lean theorem p06_random_walk, replayed by Lean's kernel and accepted by a second, separately written checker (nanoda); it rests only on Lean's standard axioms." }, { "id": "p07", "rung": 4, "claim": "Monty Hall: win probability when switching", "answer": "2/3", "how": "lean", "theorem": "p07_monty_hall", "proof": "Lean theorem p07_monty_hall, replayed by Lean's kernel and accepted by a second, separately written checker (nanoda); it rests only on Lean's standard axioms." }, { "id": "p09", "rung": 4, "claim": "Waiting for a six: expected rolls to first 6", "answer": "6 rolls", "how": "lean", "theorem": "WaitingLane.p09_rolls_to_first_six", "proof": "Lean theorem WaitingLane.p09_rolls_to_first_six, replayed by Lean's kernel and accepted by a second, separately written checker (nanoda); it rests only on Lean's standard axioms." }, { "id": "p10", "rung": 4, "claim": "Maximum of two dice: expected larger face", "answer": "161/36", "how": "lean", "theorem": "p10_max_of_two_dice", "proof": "Lean theorem p10_max_of_two_dice, replayed by Lean's kernel and accepted by a second, separately written checker (nanoda); it rests only on Lean's standard axioms." }, { "id": "p12", "rung": 4, "claim": "Three or more sixes in ten rolls", "answer": "566299/2519424", "how": "lean", "theorem": "CheapLane.p12_three_plus_sixes", "proof": "Lean theorem CheapLane.p12_three_plus_sixes, replayed by Lean's kernel and accepted by a second, separately written checker (nanoda); it rests only on Lean's standard axioms." }, { "id": "p13", "rung": 4, "claim": "Expected cards to the first ace", "answer": "53/5 cards", "how": "lean", "theorem": "TowerBatch.p13_cards_to_first_ace", "proof": "Lean theorem TowerBatch.p13_cards_to_first_ace, replayed by Lean's kernel and accepted by a second, separately written checker (nanoda); it rests only on Lean's standard axioms." }, { "id": "p17", "rung": 4, "claim": "Three-of-five vote: chance of passing at 60% yes", "answer": "2133/3125", "how": "lean", "theorem": "TowerBatch.p17_three_of_five_vote", "proof": "Lean theorem TowerBatch.p17_three_of_five_vote, replayed by Lean's kernel and accepted by a second, separately written checker (nanoda); it rests only on Lean's standard axioms." }, { "id": "p21", "rung": 0, "claim": "one specified outcome in 1,000", "answer": "1/1000", "how": "lean", "theorem": "TowerBatch.p21_rare_one_in_1000", "proof": "Lean theorem TowerBatch.p21_rare_one_in_1000, replayed by Lean's kernel and accepted by a second, separately written checker (nanoda); it rests only on Lean's standard axioms." }, { "id": "p22", "rung": 4, "claim": "St. Petersburg payout capped at 2^20", "answer": "21 dollars", "how": "lean", "theorem": "TowerBatch.p22_st_petersburg_capped", "proof": "Lean theorem TowerBatch.p22_st_petersburg_capped, replayed by Lean's kernel and accepted by a second, separately written checker (nanoda); it rests only on Lean's standard axioms." }, { "id": "p30", "rung": 0, "claim": "Area under a curve: y = x^2 from 0 to 3", "answer": "9", "how": "lean", "theorem": "CalculusLane.p30_area_under_square", "proof": "Lean theorem CalculusLane.p30_area_under_square, replayed by Lean's kernel and accepted by a second, separately written checker (nanoda); it rests only on Lean's standard axioms." }, { "id": "p31", "rung": 4, "claim": "Markov weather: rain exactly four steps after a sunny start", "answer": "2137/10000", "how": "lean", "theorem": "p31_markov_weather_four_steps", "proof": "Lean theorem p31_markov_weather_four_steps, replayed by Lean's kernel and accepted by a second, separately written checker (nanoda); it rests only on Lean's standard axioms." }, { "id": "p32", "rung": 0, "claim": "Markov token: reaching the win square before the lose square", "answer": "4/7", "how": "lean", "theorem": "CheapLane.p32_markov_token_absorption_limit", "proof": "Lean theorem CheapLane.p32_markov_token_absorption_limit, replayed by Lean's kernel and accepted by a second, separately written checker (nanoda); it rests only on Lean's standard axioms." }, { "id": "p36", "rung": 4, "claim": "Birthdays: expected number of different days among 30 people", "answer": "5840637997733944304472717260382885356354745452713098221901782271034552207449/202531728519726872798204574491055504334773427222006304748356342315673828125", "how": "lean", "theorem": "CheapLane.p36_birthday_expected_distinct", "proof": "Lean theorem CheapLane.p36_birthday_expected_distinct, replayed by Lean's kernel and accepted by a second, separately written checker (nanoda); it rests only on Lean's standard axioms." }, { "id": "p37", "rung": 0, "claim": "Random walk: reaching +3 within 12 steps", "answer": "397/1024", "how": "lean", "theorem": "p37_random_walk_hits_three", "proof": "Lean theorem p37_random_walk_hits_three, replayed by Lean's kernel and accepted by a second, separately written checker (nanoda); it rests only on Lean's standard axioms." }, { "id": "p38", "rung": 0, "claim": "Two-dimensional walk: back at the start after 6 steps", "answer": "25/256", "how": "lean", "theorem": "CheapLane.p38_random_walk_2d", "proof": "Lean theorem CheapLane.p38_random_walk_2d, replayed by Lean's kernel and accepted by a second, separately written checker (nanoda); it rests only on Lean's standard axioms." }, { "id": "p39", "rung": 0, "claim": "Random walk: expected highest point in 10 steps", "answer": "251/128", "how": "lean", "theorem": "CheapLane.p39_expected_max", "proof": "Lean theorem CheapLane.p39_expected_max, replayed by Lean's kernel and accepted by a second, separately written checker (nanoda); it rests only on Lean's standard axioms." }, { "id": "p40", "rung": 4, "claim": "Random walk: first return to the start exactly at step 10", "answer": "7/256", "how": "lean", "theorem": "CheapLane.p40_first_return_10", "proof": "Lean theorem CheapLane.p40_first_return_10, replayed by Lean's kernel and accepted by a second, separately written checker (nanoda); it rests only on Lean's standard axioms." }, { "id": "p41", "rung": 4, "claim": "Shuffle: no card back in its place among 10 cards", "answer": "16481/44800", "how": "lean", "theorem": "p41_shuffle_derangement_ten", "proof": "Lean theorem p41_shuffle_derangement_ten, replayed by Lean's kernel and accepted by a second, separately written checker (nanoda); it rests only on Lean's standard axioms." }, { "id": "p42", "rung": 4, "claim": "Shuffle: expected number of cycles in a shuffled pack of 20", "answer": "55835135/15519504", "how": "lean", "theorem": "CheapLane.p42_shuffle_expected_cycles", "proof": "Lean theorem CheapLane.p42_shuffle_expected_cycles, replayed by Lean's kernel and accepted by a second, separately written checker (nanoda); it rests only on Lean's standard axioms." }, { "id": "p43", "rung": 4, "claim": "Shuffle: some originally neighbouring pair stays together in order", "answer": "2160343/3628800", "how": "lean", "theorem": "CheapLane.p43_shuffle_kept_neighbours", "proof": "Lean theorem CheapLane.p43_shuffle_kept_neighbours, replayed by Lean's kernel and accepted by a second, separately written checker (nanoda); it rests only on Lean's standard axioms." }, { "id": "p44", "rung": 4, "claim": "Cards: a 13-card hand with no spades but every other suit present", "answer": "8091223647/635013559600", "how": "lean", "theorem": "CheapLane.p44_bridge_hand_no_spades", "proof": "Lean theorem CheapLane.p44_bridge_hand_no_spades, replayed by Lean's kernel and accepted by a second, separately written checker (nanoda); it rests only on Lean's standard axioms." }, { "id": "p45", "rung": 4, "claim": "Cards: all four aces appear before any king in a shuffled deck", "answer": "1/70", "how": "lean", "theorem": "CheapLane.p45_aces_before_kings", "proof": "Lean theorem CheapLane.p45_aces_before_kings, replayed by Lean's kernel and accepted by a second, separately written checker (nanoda); it rests only on Lean's standard axioms." }, { "id": "p48", "rung": 0, "claim": "At least 3 successes in 12 trials, each a success with chance 1/3", "answer": "435185/531441", "how": "lean", "theorem": "TowerBatch.p48_third_success_by_twelve", "proof": "Lean theorem TowerBatch.p48_third_success_by_twelve, replayed by Lean's kernel and accepted by a second, separately written checker (nanoda); it rests only on Lean's standard axioms." }, { "id": "p49", "rung": 4, "claim": "Polya urn: exactly three reds in five draws", "answer": "4/21", "how": "lean", "theorem": "CheapLane.p49_polya_three_reds", "proof": "Lean theorem CheapLane.p49_polya_three_reds, replayed by Lean's kernel and accepted by a second, separately written checker (nanoda); it rests only on Lean's standard axioms." }, { "id": "p52", "rung": 0, "claim": "Random walk: never below the start and back at it after 12 steps", "answer": "33/1024", "how": "lean", "theorem": "p52_random_walk_never_negative", "proof": "Lean theorem p52_random_walk_never_negative, replayed by Lean's kernel and accepted by a second, separately written checker (nanoda); it rests only on Lean's standard axioms." }, { "id": "p53", "rung": 4, "claim": "Birthdays: expected number of same-birthday pairs among 28 people", "answer": "378/365 pairs", "how": "lean", "theorem": "CheapLane.p53_birthday_expected_pairs", "proof": "Lean theorem CheapLane.p53_birthday_expected_pairs, replayed by Lean's kernel and accepted by a second, separately written checker (nanoda); it rests only on Lean's standard axioms." }, { "id": "p56", "rung": 4, "claim": "expected value of a wide lognormal payout", "answer": "exp(2)", "how": "lean", "theorem": "WaitingLane.p56_lognormal_mean", "proof": "Lean theorem WaitingLane.p56_lognormal_mean, replayed by Lean's kernel and accepted by a second, separately written checker (nanoda); it rests only on Lean's standard axioms." }, { "id": "p63", "rung": 0, "claim": "two numbers up to 1,000 share no common factor", "answer": "608383/1000000", "how": "lean", "theorem": "CheapLane.p63_trap_coprime_pair_finite", "proof": "Lean theorem CheapLane.p63_trap_coprime_pair_finite, replayed by Lean's kernel and accepted by a second, separately written checker (nanoda); it rests only on Lean's standard axioms." }, { "id": "p65", "rung": 4, "claim": "A 13-card hand from a shuffled deck holds all four aces and all four kings", "answer": "11/6431950", "how": "lean", "theorem": "TowerBatch.p65_trap_bridge_aces_kings", "proof": "Lean theorem TowerBatch.p65_trap_bridge_aces_kings, replayed by Lean's kernel and accepted by a second, separately written checker (nanoda); it rests only on Lean's standard axioms." }, { "id": "p65b", "rung": 4, "claim": "chance of disease after a positive 99%-sensitive test", "answer": "11/122", "how": "lean", "theorem": "TowerBatch.p65_trap_medical_test_positive", "proof": "Lean theorem TowerBatch.p65_trap_medical_test_positive, replayed by Lean's kernel and accepted by a second, separately written checker (nanoda); it rests only on Lean's standard axioms." }, { "id": "p68", "rung": 4, "claim": "all five backup units fail, with a rare common shock", "answer": "10000000999/10000000000000", "how": "lean", "theorem": "TowerBatch.p68_trap_common_shock_failure", "proof": "Lean theorem TowerBatch.p68_trap_common_shock_failure, replayed by Lean's kernel and accepted by a second, separately written checker (nanoda); it rests only on Lean's standard axioms." }, { "id": "p69", "rung": 4, "claim": "Twenty fair dice total 30 or less", "answer": "9944165/1218719480020992", "how": "lean", "theorem": "TowerBatch.p69_trap_twenty_dice_low_tail", "proof": "Lean theorem TowerBatch.p69_trap_twenty_dice_low_tail, replayed by Lean's kernel and accepted by a second, separately written checker (nanoda); it rests only on Lean's standard axioms." }, { "id": "p69b", "rung": 4, "claim": "days 100 and 101 are both rainfall records", "answer": "1/10100", "how": "lean", "theorem": "TowerBatch.p69_trap_two_records_in_row", "proof": "Lean theorem TowerBatch.p69_trap_two_records_in_row, replayed by Lean's kernel and accepted by a second, separately written checker (nanoda); it rests only on Lean's standard axioms." }, { "id": "p83", "rung": 4, "claim": "Floating block: submerged depth of a wooden block", "answer": "3/10 m", "how": "lean", "theorem": "PhysicsLane.p83_floating_block_depth", "proof": "Lean theorem PhysicsLane.p83_floating_block_depth, replayed by Lean's kernel and accepted by a second, separately written checker (nanoda); it rests only on Lean's standard axioms." }, { "id": "p88", "rung": 4, "claim": "Elastic collision: speed of the 2 kg cart after a head-on hit", "answer": "1 m/s", "how": "lean", "theorem": "PhysicsLane.p88_elastic_two_kg_cart", "proof": "Lean theorem PhysicsLane.p88_elastic_two_kg_cart, replayed by Lean's kernel and accepted by a second, separately written checker (nanoda); it rests only on Lean's standard axioms." }, { "id": "p91", "rung": 0, "claim": "Integral: area under exp(x) from 0 to 1", "answer": "e-1", "how": "lean", "theorem": "CalculusLane.p91_exp_area", "proof": "Lean theorem CalculusLane.p91_exp_area, replayed by Lean's kernel and accepted by a second, separately written checker (nanoda); it rests only on Lean's standard axioms." }, { "id": "p92", "rung": 0, "claim": "Integral: area under one arch of the sine curve", "answer": "2", "how": "lean", "theorem": "CalculusLane.p92_sine_arch", "proof": "Lean theorem CalculusLane.p92_sine_arch, replayed by Lean's kernel and accepted by a second, separately written checker (nanoda); it rests only on Lean's standard axioms." }, { "id": "p93", "rung": 0, "claim": "Series: the sum of 1/k^2 over all positive integers", "answer": "pi^2/6", "how": "lean", "theorem": "SeriesLane.p93_basel", "proof": "Lean theorem SeriesLane.p93_basel, replayed by Lean's kernel and accepted by a second, separately written checker (nanoda); it rests only on Lean's standard axioms." }, { "id": "p94", "rung": 0, "claim": "Series: the sum of k/2^k over all positive integers", "answer": "2", "how": "lean", "theorem": "SeriesLane.p94_k_over_two_pow", "proof": "Lean theorem SeriesLane.p94_k_over_two_pow, replayed by Lean's kernel and accepted by a second, separately written checker (nanoda); it rests only on Lean's standard axioms." }, { "id": "p95", "rung": 0, "claim": "Root finding: the positive root of x^2 = 2", "answer": "sqrt(2)", "how": "lean", "theorem": "RootsLane.p95_positive_root_of_two", "proof": "Lean theorem RootsLane.p95_positive_root_of_two, replayed by Lean's kernel and accepted by a second, separately written checker (nanoda); it rests only on Lean's standard axioms." }, { "id": "p97", "rung": 3, "claim": "ODE: logistic growth from 10 toward a cap of 100 after 2 days", "answer": "50", "how": "lean", "theorem": "CalculusLane.p97_logistic", "proof": "Lean theorem CalculusLane.p97_logistic, replayed by Lean's kernel and accepted by a second, separately written checker (nanoda); it rests only on Lean's standard axioms." }, { "id": "p98", "rung": 0, "claim": "ODE: value of the oscillator y'' + 4y = 0 at t = pi/6", "answer": "1/2", "how": "lean", "theorem": "CalculusLane.p98_oscillator", "proof": "Lean theorem CalculusLane.p98_oscillator, replayed by Lean's kernel and accepted by a second, separately written checker (nanoda); it rests only on Lean's standard axioms." }, { "id": "p99", "rung": 0, "claim": "Series: the sum of 1/(k(k+1)) over all positive integers", "answer": "1", "how": "lean", "theorem": "SeriesLane.p99_telescoping", "proof": "Lean theorem SeriesLane.p99_telescoping, replayed by Lean's kernel and accepted by a second, separately written checker (nanoda); it rests only on Lean's standard axioms." }, { "id": "p100", "rung": 0, "claim": "Integral: area under log(x)/x from 1 to e", "answer": "1/2", "how": "lean", "theorem": "CalculusLane.p100_log_over_x", "proof": "Lean theorem CalculusLane.p100_log_over_x, replayed by Lean's kernel and accepted by a second, separately written checker (nanoda); it rests only on Lean's standard axioms." }, { "id": "m0", "rung": 0, "claim": "There are infinitely many prime numbers: past any number, there is always another prime", "answer": "Nat.exists_infinite_primes (n : ℕ) : ∃ p, n ≤ p ∧ Nat.Prime p", "how": "lean", "source": "mathlib", "theorem": "Nat.exists_infinite_primes", "added": "2026-10-29", "proof": "Lean theorem Nat.exists_infinite_primes from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m1", "rung": 0, "claim": "Bertrand's postulate: between any whole number n above zero and 2n there is always a prime", "answer": "Nat.exists_prime_lt_and_le_two_mul (n : ℕ) (hn0 : n ≠ 0) : ∃ p, Nat.Prime p ∧ n < p ∧ p ≤ 2 * n", "how": "lean", "source": "mathlib", "theorem": "Nat.exists_prime_lt_and_le_two_mul", "added": "2026-10-29", "proof": "Lean theorem Nat.exists_prime_lt_and_le_two_mul from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m2", "rung": 0, "claim": "Dirichlet's theorem: if a and n share no factor, infinitely many primes leave remainder a when divided by n", "answer": "Nat.infinite_setOfPred_prime_and_eq_mod {q : ℕ} [NeZero q] {a : ZMod q} (ha : IsUnit a) : {p | Nat.Prime p ∧ ↑p = a}.Infinite", "how": "lean", "source": "mathlib", "theorem": "Nat.infinite_setOfPred_prime_and_eq_mod", "added": "2026-10-29", "proof": "Lean theorem Nat.infinite_setOfPred_prime_and_eq_mod from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m3", "rung": 0, "claim": "The square root of 2 is not a fraction of two whole numbers", "answer": "irrational_sqrt_two : Irrational √2", "how": "lean", "source": "mathlib", "theorem": "irrational_sqrt_two", "added": "2026-10-29", "proof": "Lean theorem irrational_sqrt_two from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m4", "rung": 0, "claim": "Pi is not a fraction of two whole numbers", "answer": "irrational_pi : Irrational Real.pi", "how": "lean", "source": "mathlib", "theorem": "irrational_pi", "added": "2026-10-29", "proof": "Lean theorem irrational_pi from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m5", "rung": 0, "claim": "The golden ratio is not a fraction of two whole numbers", "answer": "Real.goldenRatio_irrational : Irrational Real.goldenRatio", "how": "lean", "source": "mathlib", "theorem": "Real.goldenRatio_irrational", "added": "2026-10-29", "proof": "Lean theorem Real.goldenRatio_irrational from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m6", "rung": 0, "claim": "Liouville numbers are transcendental: they are not the root of any polynomial with whole-number coefficients", "answer": "Liouville.transcendental {x : ℝ} (lx : Liouville x) : Transcendental ℤ x", "how": "lean", "source": "mathlib", "theorem": "Liouville.transcendental", "added": "2026-10-29", "proof": "Lean theorem Liouville.transcendental from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m7", "rung": 0, "claim": "Pi is bigger than 3", "answer": "Real.pi_gt_three : 3 < Real.pi", "how": "lean", "source": "mathlib", "theorem": "Real.pi_gt_three", "added": "2026-10-29", "proof": "Lean theorem Real.pi_gt_three from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m8", "rung": 0, "claim": "Pi is bigger than 3.14", "answer": "Real.pi_gt_d2 : 3.14 < Real.pi", "how": "lean", "source": "mathlib", "theorem": "Real.pi_gt_d2", "added": "2026-10-29", "proof": "Lean theorem Real.pi_gt_d2 from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m9", "rung": 0, "claim": "Pi is smaller than 3.15", "answer": "Real.pi_lt_d2 : Real.pi < 3.15", "how": "lean", "source": "mathlib", "theorem": "Real.pi_lt_d2", "added": "2026-10-29", "proof": "Lean theorem Real.pi_lt_d2 from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m10", "rung": 0, "claim": "Euler's identity: e raised to pi times i equals -1", "answer": "Complex.exp_pi_mul_I : Complex.exp (↑Real.pi * Complex.I) = -1", "how": "lean", "source": "mathlib", "theorem": "Complex.exp_pi_mul_I", "added": "2026-10-29", "proof": "Lean theorem Complex.exp_pi_mul_I from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m11", "rung": 0, "claim": "For every angle, sine squared plus cosine squared equals 1", "answer": "Real.sin_sq_add_cos_sq (x : ℝ) : Real.sin x ^ 2 + Real.cos x ^ 2 = 1", "how": "lean", "source": "mathlib", "theorem": "Real.sin_sq_add_cos_sq", "added": "2026-10-29", "proof": "Lean theorem Real.sin_sq_add_cos_sq from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m12", "rung": 0, "claim": "The Basel problem: 1 + 1/4 + 1/9 + 1/16 + ... adds up to exactly pi squared over 6", "answer": "hasSum_zeta_two : HasSum (fun n => 1 / ↑n ^ 2) (Real.pi ^ 2 / 6)", "how": "lean", "source": "mathlib", "theorem": "hasSum_zeta_two", "added": "2026-10-29", "proof": "Lean theorem hasSum_zeta_two from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m13", "rung": 0, "claim": "The harmonic series 1 + 1/2 + 1/3 + 1/4 + ... grows past every number", "answer": "Real.tendsto_sum_range_one_div_nat_succ_atTop : Filter.Tendsto (fun n => ∑ i ∈ Finset.range n, 1 / (↑i + 1)) Filter.atTop Filter.atTop", "how": "lean", "source": "mathlib", "theorem": "Real.tendsto_sum_range_one_div_nat_succ_atTop", "added": "2026-10-29", "proof": "Lean theorem Real.tendsto_sum_range_one_div_nat_succ_atTop from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m14", "rung": 0, "claim": "Gauss's sum: twice the sum 0 + 1 + ... + (n - 1) equals n times (n - 1)", "answer": "Finset.sum_range_id_mul_two (n : ℕ) : (∑ i ∈ Finset.range n, i) * 2 = n * (n - 1)", "how": "lean", "source": "mathlib", "theorem": "Finset.sum_range_id_mul_two", "added": "2026-10-29", "proof": "Lean theorem Finset.sum_range_id_mul_two from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m15", "rung": 0, "claim": "Adding up row n of Pascal's triangle gives exactly 2 to the power n", "answer": "Nat.sum_range_choose (n : ℕ) : ∑ m ∈ Finset.range (n + 1), n.choose m = 2 ^ n", "how": "lean", "source": "mathlib", "theorem": "Nat.sum_range_choose", "added": "2026-10-29", "proof": "Lean theorem Nat.sum_range_choose from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m16", "rung": 0, "claim": "A set with n things has exactly 2 to the power n subsets", "answer": "Finset.card_powerset.{u_1} {α : Type u_1} (s : Finset α) : s.powerset.card = 2 ^ s.card", "how": "lean", "source": "mathlib", "theorem": "Finset.card_powerset", "added": "2026-10-29", "proof": "Lean theorem Finset.card_powerset from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m17", "rung": 0, "claim": "n different things can be put in order in exactly n factorial ways", "answer": "Fintype.card_perm.{u_1} {α : Type u_1} [DecidableEq α] [Fintype α] : Fintype.card (Equiv.Perm α) = (Fintype.card α).factorial", "how": "lean", "source": "mathlib", "theorem": "Fintype.card_perm", "added": "2026-10-29", "proof": "Lean theorem Fintype.card_perm from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m18", "rung": 0, "claim": "Fermat's little theorem: for a prime p, any number not divisible by p, raised to p - 1, leaves remainder 1 when divided by p", "answer": "ZMod.pow_card_sub_one_eq_one {p : ℕ} [Fact (Nat.Prime p)] {a : ZMod p} (ha : a ≠ 0) : a ^ (p - 1) = 1", "how": "lean", "source": "mathlib", "theorem": "ZMod.pow_card_sub_one_eq_one", "added": "2026-10-29", "proof": "Lean theorem ZMod.pow_card_sub_one_eq_one from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m19", "rung": 0, "claim": "Wilson's theorem: for a prime p, (p - 1) factorial leaves remainder p - 1 when divided by p", "answer": "ZMod.wilsons_lemma (p : ℕ) [Fact (Nat.Prime p)] : ↑(p - 1).factorial = -1", "how": "lean", "source": "mathlib", "theorem": "ZMod.wilsons_lemma", "added": "2026-10-29", "proof": "Lean theorem ZMod.wilsons_lemma from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m20", "rung": 0, "claim": "Fermat's two squares theorem: every prime that leaves remainder 1 when divided by 4 is a sum of two squares", "answer": "Nat.Prime.sq_add_sq {p : ℕ} [Fact (Nat.Prime p)] (hp : p % 4 ≠ 3) : ∃ a b, a ^ 2 + b ^ 2 = p", "how": "lean", "source": "mathlib", "theorem": "Nat.Prime.sq_add_sq", "added": "2026-10-29", "proof": "Lean theorem Nat.Prime.sq_add_sq from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m21", "rung": 0, "claim": "Lagrange's four squares theorem: every whole number is a sum of four squares", "answer": "Nat.sum_four_squares (n : ℕ) : ∃ a b c d, a ^ 2 + b ^ 2 + c ^ 2 + d ^ 2 = n", "how": "lean", "source": "mathlib", "theorem": "Nat.sum_four_squares", "added": "2026-10-29", "proof": "Lean theorem Nat.sum_four_squares from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m22", "rung": 0, "claim": "Quadratic reciprocity: for two different odd primes, whether each is a square remainder for the other is linked by one exact sign rule", "answer": "legendreSym.quadratic_reciprocity {p q : ℕ} [Fact (Nat.Prime p)] [Fact (Nat.Prime q)] (hp : p ≠ 2) (hq : q ≠ 2) (hpq : p ≠ q) : legendreSym q ↑p * legendreSym p ↑q = (-1) ^ (p / 2 * (q / 2))", "how": "lean", "source": "mathlib", "theorem": "legendreSym.quadratic_reciprocity", "added": "2026-10-29", "proof": "Lean theorem legendreSym.quadratic_reciprocity from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m23", "rung": 0, "claim": "Fermat's Last Theorem for power 4: no whole numbers above zero solve a^4 + b^4 = c^4", "answer": "fermatLastTheoremFour : FermatLastTheoremFor 4", "how": "lean", "source": "mathlib", "theorem": "fermatLastTheoremFour", "added": "2026-10-29", "proof": "Lean theorem fermatLastTheoremFour from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m24", "rung": 0, "claim": "Fermat's Last Theorem for power 3: no whole numbers above zero solve a^3 + b^3 = c^3", "answer": "fermatLastTheoremThree : FermatLastTheoremFor 3", "how": "lean", "source": "mathlib", "theorem": "fermatLastTheoremThree", "added": "2026-10-29", "proof": "Lean theorem fermatLastTheoremThree from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m25", "rung": 0, "claim": "The fundamental theorem of algebra: every polynomial of degree 1 or more has a root among the complex numbers", "answer": "Complex.exists_root {f : Polynomial ℂ} (hf : 0 < f.degree) : ∃ z, f.IsRoot z", "how": "lean", "source": "mathlib", "theorem": "Complex.exists_root", "added": "2026-10-29", "proof": "Lean theorem Complex.exists_root from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m26", "rung": 0, "claim": "The intermediate value theorem: a continuous curve from a low point to a high point passes through every height in between", "answer": "intermediate_value_Icc.{u, u_1} {α : Type u} [TopologicalSpace α] [ConditionallyCompleteLinearOrder α] [OrderTopology α] [DenselyOrdered α] {δ : Type u_1} [LinearOrder δ] [TopologicalSpace δ] [OrderClosedTopology δ] {a b : α} (hab : a ≤ b) {f : α → δ} (hf : ContinuousOn f (Set.Icc a b)) : Set.Icc (f a) (f b) ⊆ f '' Set.Icc a b", "how": "lean", "source": "mathlib", "theorem": "intermediate_value_Icc", "added": "2026-10-29", "proof": "Lean theorem intermediate_value_Icc from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m27", "rung": 0, "claim": "The extreme value theorem: a continuous function on a closed, bounded, non-empty set reaches a lowest value", "answer": "IsCompact.exists_isMinOn.{u_2, u_3} {α : Type u_2} {β : Type u_3} [LinearOrder α] [TopologicalSpace α] [TopologicalSpace β] [ClosedIicTopology α] {s : Set β} (hs : IsCompact s) (ne_s : s.Nonempty) {f : β → α} (hf : ContinuousOn f s) : ∃ x ∈ s, IsMinOn f s x", "how": "lean", "source": "mathlib", "theorem": "IsCompact.exists_isMinOn", "added": "2026-10-29", "proof": "Lean theorem IsCompact.exists_isMinOn from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m28", "rung": 0, "claim": "The mean value theorem: a smooth curve somewhere has a slope equal to the average slope between its two ends", "answer": "exists_hasDerivAt_eq_slope (f f' : ℝ → ℝ) {a b : ℝ} (hab : a < b) (hfc : ContinuousOn f (Set.Icc a b)) (hff' : ∀ x ∈ Set.Ioo a b, HasDerivAt f (f' x) x) : ∃ c ∈ Set.Ioo a b, f' c = (f b - f a) / (b - a)", "how": "lean", "source": "mathlib", "theorem": "exists_hasDerivAt_eq_slope", "added": "2026-10-29", "proof": "Lean theorem exists_hasDerivAt_eq_slope from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m29", "rung": 0, "claim": "Cantor's theorem: every set has strictly more subsets than it has members, even an infinite one", "answer": "Cardinal.cantor.{u} (a : Cardinal.{u}) : a < 2 ^ a", "how": "lean", "source": "mathlib", "theorem": "Cardinal.cantor", "added": "2026-10-29", "proof": "Lean theorem Cardinal.cantor from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m30", "rung": 0, "claim": "The real numbers cannot be listed one by one: there are more of them than whole numbers", "answer": "Cardinal.not_countable_real : ¬Set.univ.Countable", "how": "lean", "source": "mathlib", "theorem": "Cardinal.not_countable_real", "added": "2026-10-29", "proof": "Lean theorem Cardinal.not_countable_real from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m31", "rung": 0, "claim": "Lagrange's theorem: in a finite group, the size of any subgroup divides the size of the group", "answer": "Subgroup.card_subgroup_dvd_card.{u_1} {α : Type u_1} [Group α] (s : Subgroup α) : Nat.card ↥s ∣ Nat.card α", "how": "lean", "source": "mathlib", "theorem": "Subgroup.card_subgroup_dvd_card", "added": "2026-10-29", "proof": "Lean theorem Subgroup.card_subgroup_dvd_card from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m32", "rung": 0, "claim": "Sylow's first theorem: if p^n divides the size of a finite group, the group has a subgroup of exactly that size", "answer": "Sylow.exists_subgroup_card_pow_prime.{u} {G : Type u} [Group G] [Finite G] (p : ℕ) {n : ℕ} [Fact (Nat.Prime p)] (hdvd : p ^ n ∣ Nat.card G) : ∃ K, Nat.card ↥K = p ^ n", "how": "lean", "source": "mathlib", "theorem": "Sylow.exists_subgroup_card_pow_prime", "added": "2026-10-29", "proof": "Lean theorem Sylow.exists_subgroup_card_pow_prime from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m33", "rung": 0, "claim": "Pythagoras: in a triangle, the long side squared equals the sum of the other two squared exactly when their angle is a right angle", "answer": "EuclideanGeometry.dist_sq_eq_dist_sq_add_dist_sq_iff_angle_eq_pi_div_two.{u_1, u_2} {V : Type u_1} {P : Type u_2} [NormedAddCommGroup V] [InnerProductSpace ℝ V] [MetricSpace P] [NormedAddTorsor V P] (p₁ p₂ p₃ : P) : dist p₁ p₃ * dist p₁ p₃ = dist p₁ p₂ * dist p₁ p₂ + dist p₃ p₂ * dist p₃ p₂ ↔ EuclideanGeometry.angle p₁ p₂ p₃ = Real.pi / 2", "how": "lean", "source": "mathlib", "theorem": "EuclideanGeometry.dist_sq_eq_dist_sq_add_dist_sq_iff_angle_eq_pi_div_two", "added": "2026-10-29", "proof": "Lean theorem EuclideanGeometry.dist_sq_eq_dist_sq_add_dist_sq_iff_angle_eq_pi_div_two from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m34", "rung": 0, "claim": "The Cauchy-Schwarz inequality: the size of the dot product of two real vectors is never bigger than their lengths multiplied", "answer": "abs_real_inner_le_norm.{u_3} {F : Type u_3} [SeminormedAddCommGroup F] [InnerProductSpace ℝ F] (x y : F) : |inner ℝ x y| ≤ ‖x‖ * ‖y‖", "how": "lean", "source": "mathlib", "theorem": "abs_real_inner_le_norm", "added": "2026-10-29", "proof": "Lean theorem abs_real_inner_le_norm from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m35", "rung": 0, "claim": "The number e is bigger than 2.7182818283", "answer": "Real.exp_one_gt_d9 : 2.7182818283 < Real.exp 1", "how": "lean", "source": "mathlib", "theorem": "Real.exp_one_gt_d9", "added": "2026-10-29", "proof": "Lean theorem Real.exp_one_gt_d9 from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m36", "rung": 0, "claim": "The number e is smaller than 2.7182818286", "answer": "Real.exp_one_lt_d9 : Real.exp 1 < 2.7182818286", "how": "lean", "source": "mathlib", "theorem": "Real.exp_one_lt_d9", "added": "2026-10-29", "proof": "Lean theorem Real.exp_one_lt_d9 from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m37", "rung": 0, "claim": "Every prime number is at least 2", "answer": "Nat.Prime.two_le {p : ℕ} : Nat.Prime p → 2 ≤ p", "how": "lean", "source": "mathlib", "theorem": "Nat.Prime.two_le", "added": "2026-10-29", "proof": "Lean theorem Nat.Prime.two_le from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m38", "rung": 0, "claim": "Euler's theorem: a number with no factor in common with n, raised to the count of such numbers below n, leaves remainder 1 when divided by n", "answer": "Nat.ModEq.pow_totient {x n : ℕ} (h : x.Coprime n) : x ^ n.totient ≡ 1 [MOD n]", "how": "lean", "source": "mathlib", "theorem": "Nat.ModEq.pow_totient", "added": "2026-10-29", "proof": "Lean theorem Nat.ModEq.pow_totient from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m39", "rung": 0, "claim": "For any two whole numbers, their greatest common divisor times their least common multiple equals the two numbers multiplied", "answer": "Nat.gcd_mul_lcm (m n : ℕ) : m.gcd n * m.lcm n = m * n", "how": "lean", "source": "mathlib", "theorem": "Nat.gcd_mul_lcm", "added": "2026-10-29", "proof": "Lean theorem Nat.gcd_mul_lcm from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m40", "rung": 0, "claim": "Bezout's identity: the greatest common divisor of two numbers is always a whole-number combination of them", "answer": "Nat.gcd_eq_gcd_ab (x y : ℕ) : ↑(x.gcd y) = ↑x * x.gcdA y + ↑y * x.gcdB y", "how": "lean", "source": "mathlib", "theorem": "Nat.gcd_eq_gcd_ab", "added": "2026-10-29", "proof": "Lean theorem Nat.gcd_eq_gcd_ab from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m41", "rung": 0, "claim": "Every whole number other than 1 has a prime number that divides it", "answer": "Nat.exists_prime_and_dvd {n : ℕ} (hn : n ≠ 1) : ∃ p, Nat.Prime p ∧ p ∣ n", "how": "lean", "source": "mathlib", "theorem": "Nat.exists_prime_and_dvd", "added": "2026-10-29", "proof": "Lean theorem Nat.exists_prime_and_dvd from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m42", "rung": 0, "claim": "The square root of any prime number is irrational: no fraction equals it", "answer": "Nat.Prime.irrational_sqrt {p : ℕ} (hp : Nat.Prime p) : Irrational √↑p", "how": "lean", "source": "mathlib", "theorem": "Nat.Prime.irrational_sqrt", "added": "2026-10-29", "proof": "Lean theorem Nat.Prime.irrational_sqrt from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m43", "rung": 0, "claim": "The binomial theorem: (x + y) to the power n expands into a sum with the binomial coefficients", "answer": "add_pow.{u_1} {R : Type u_1} [CommSemiring R] (x y : R) (n : ℕ) : (x + y) ^ n = ∑ m ∈ Finset.range (n + 1), x ^ m * y ^ (n - m) * ↑(n.choose m)", "how": "lean", "source": "mathlib", "theorem": "add_pow", "added": "2026-10-29", "proof": "Lean theorem add_pow from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m44", "rung": 0, "claim": "The pigeonhole principle: put more things into fewer boxes and some box gets two", "answer": "Finset.exists_ne_map_eq_of_card_lt_of_maps_to.{u_1, u_2} {α : Type u_1} {β : Type u_2} {s : Finset α} {t : Finset β} (hc : t.card < s.card) {f : α → β} (hf : Set.MapsTo f ↑s ↑t) : ∃ x ∈ s, ∃ y ∈ s, x ≠ y ∧ f x = f y", "how": "lean", "source": "mathlib", "theorem": "Finset.exists_ne_map_eq_of_card_lt_of_maps_to", "added": "2026-10-29", "proof": "Lean theorem Finset.exists_ne_map_eq_of_card_lt_of_maps_to from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m45", "rung": 0, "claim": "A geometric series 1 + r + r^2 + ... with r between 0 and 1 adds up to exactly 1 / (1 - r)", "answer": "tsum_geometric_of_lt_one {r : ℝ} (h₁ : 0 ≤ r) (h₂ : r < 1) : ∑' (n : ℕ), r ^ n = (1 - r)⁻¹", "how": "lean", "source": "mathlib", "theorem": "tsum_geometric_of_lt_one", "added": "2026-10-29", "proof": "Lean theorem tsum_geometric_of_lt_one from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m46", "rung": 0, "claim": "The fundamental theorem of calculus: the integral of a derivative is the change in the original function", "answer": "intervalIntegral.integral_eq_sub_of_hasDerivAt.{u_3} {E : Type u_3} [NormedAddCommGroup E] [NormedSpace ℝ E] {a b : ℝ} [CompleteSpace E] {f f' : ℝ → E} (hderiv : ∀ x ∈ Set.uIcc a b, HasDerivAt f (f' x) x) (hint : IntervalIntegrable f' MeasureTheory.volume a b) : ∫ (y : ℝ) in a..b, f' y = f b - f a", "how": "lean", "source": "mathlib", "theorem": "intervalIntegral.integral_eq_sub_of_hasDerivAt", "added": "2026-10-29", "proof": "Lean theorem intervalIntegral.integral_eq_sub_of_hasDerivAt from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m47", "rung": 0, "claim": "Rolle's theorem: a smooth curve that starts and ends at the same height is flat somewhere in between", "answer": "exists_deriv_eq_zero {f : ℝ → ℝ} {a b : ℝ} (hab : a < b) (hfc : ContinuousOn f (Set.Icc a b)) (hfI : f a = f b) : ∃ c ∈ Set.Ioo a b, deriv f c = 0", "how": "lean", "source": "mathlib", "theorem": "exists_deriv_eq_zero", "added": "2026-10-29", "proof": "Lean theorem exists_deriv_eq_zero from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m48", "rung": 0, "claim": "The Schroeder-Bernstein theorem: if each of two sets fits one-to-one inside the other, they are the same size", "answer": "Function.Embedding.schroeder_bernstein.{u, v} {α : Type u} {β : Type v} {f : α → β} {g : β → α} (hf : Function.Injective f) (hg : Function.Injective g) : ∃ h, Function.Bijective h", "how": "lean", "source": "mathlib", "theorem": "Function.Embedding.schroeder_bernstein", "added": "2026-10-29", "proof": "Lean theorem Function.Embedding.schroeder_bernstein from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m49", "rung": 0, "claim": "The Banach fixed point theorem: a map that always pulls points closer together has a point it leaves where it is", "answer": "ContractingWith.fixedPoint_isFixedPt.{u_1} {α : Type u_1} [MetricSpace α] {K : NNReal} {f : α → α} (hf : ContractingWith K f) [Nonempty α] [CompleteSpace α] : Function.IsFixedPt f (ContractingWith.fixedPoint f hf)", "how": "lean", "source": "mathlib", "theorem": "ContractingWith.fixedPoint_isFixedPt", "added": "2026-10-29", "proof": "Lean theorem ContractingWith.fixedPoint_isFixedPt from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m50", "rung": 0, "claim": "The halting problem: no program can decide, for every program, whether it eventually stops", "answer": "ComputablePred.halting_problem (n : ℕ) : ¬ComputablePred fun c => (c.eval n).Dom", "how": "lean", "source": "mathlib", "theorem": "ComputablePred.halting_problem", "added": "2026-10-29", "proof": "Lean theorem ComputablePred.halting_problem from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m51", "rung": 0, "claim": "Dirichlet's approximation theorem: every real number is close to a fraction with a small bottom", "answer": "Real.exists_int_int_abs_mul_sub_le (ξ : ℝ) {n : ℕ} (n_pos : 0 < n) : ∃ j k, 0 < k ∧ k ≤ ↑n ∧ |↑k * ξ - ↑j| ≤ 1 / (↑n + 1)", "how": "lean", "source": "mathlib", "theorem": "Real.exists_int_int_abs_mul_sub_le", "added": "2026-10-29", "proof": "Lean theorem Real.exists_int_int_abs_mul_sub_le from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m52", "rung": 0, "claim": "There are exactly as many real numbers as there are sets of whole numbers", "answer": "Cardinal.mk_real : Cardinal.mk ℝ = Cardinal.continuum", "how": "lean", "source": "mathlib", "theorem": "Cardinal.mk_real", "added": "2026-10-29", "proof": "Lean theorem Cardinal.mk_real from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m53", "rung": 0, "claim": "For every real number x, 1 + x is at most e to the power x", "answer": "Real.add_one_le_exp (x : ℝ) : x + 1 ≤ Real.exp x", "how": "lean", "source": "mathlib", "theorem": "Real.add_one_le_exp", "added": "2026-10-29", "proof": "Lean theorem Real.add_one_le_exp from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m54", "rung": 0, "claim": "Bernoulli's inequality: (1 + x) to the power n is at least 1 + n times x", "answer": "one_add_mul_le_pow.{u_1} {R : Type u_1} [Ring R] [LinearOrder R] [IsStrictOrderedRing R] {a : R} (H : -2 ≤ a) (n : ℕ) : 1 + ↑n * a ≤ (1 + a) ^ n", "how": "lean", "source": "mathlib", "theorem": "one_add_mul_le_pow", "added": "2026-10-29", "proof": "Lean theorem one_add_mul_le_pow from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m55", "rung": 0, "claim": "The triangle inequality: the length of a sum is at most the sum of the lengths", "answer": "norm_add_le.{u_4} {E : Type u_4} [SeminormedAddGroup E] (a b : E) : ‖a + b‖ ≤ ‖a‖ + ‖b‖", "how": "lean", "source": "mathlib", "theorem": "norm_add_le", "added": "2026-10-29", "proof": "Lean theorem norm_add_le from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m56", "rung": 0, "claim": "The weighted mean inequality: a geometric mean is never more than the arithmetic mean", "answer": "Real.geom_mean_le_arith_mean2_weighted {w₁ w₂ p₁ p₂ : ℝ} (hw₁ : 0 ≤ w₁) (hw₂ : 0 ≤ w₂) (hp₁ : 0 ≤ p₁) (hp₂ : 0 ≤ p₂) (hw : w₁ + w₂ = 1) : p₁ ^ w₁ * p₂ ^ w₂ ≤ w₁ * p₁ + w₂ * p₂", "how": "lean", "source": "mathlib", "theorem": "Real.geom_mean_le_arith_mean2_weighted", "added": "2026-10-29", "proof": "Lean theorem Real.geom_mean_le_arith_mean2_weighted from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m57", "rung": 0, "claim": "A triangle's three angles add up to 180 degrees (pi)", "answer": "EuclideanGeometry.angle_add_angle_add_angle_eq_pi.{u_1, u_2} {V : Type u_1} {P : Type u_2} [NormedAddCommGroup V] [InnerProductSpace ℝ V] [MetricSpace P] [NormedAddTorsor V P] {p₁ p₂ : P} (p₃ : P) (h : p₂ ≠ p₁) : EuclideanGeometry.angle p₁ p₂ p₃ + EuclideanGeometry.angle p₂ p₃ p₁ + EuclideanGeometry.angle p₃ p₁ p₂ = Real.pi", "how": "lean", "source": "mathlib", "theorem": "EuclideanGeometry.angle_add_angle_add_angle_eq_pi", "added": "2026-10-29", "proof": "Lean theorem EuclideanGeometry.angle_add_angle_add_angle_eq_pi from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m58", "rung": 0, "claim": "Every Pythagorean triple comes from one formula (Euclid)", "answer": "PythagoreanTriple.classification {x y z : ℤ} : PythagoreanTriple x y z ↔ ∃ k m n, (x = k * (m ^ 2 - n ^ 2) ∧ y = k * (2 * m * n) ∨ x = k * (2 * m * n) ∧ y = k * (m ^ 2 - n ^ 2)) ∧ (z = k * (m ^ 2 + n ^ 2) ∨ z = -k * (m ^ 2 + n ^ 2))", "how": "lean", "source": "mathlib", "theorem": "PythagoreanTriple.classification", "added": "2026-10-29", "proof": "Lean theorem PythagoreanTriple.classification from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m59", "rung": 0, "claim": "Cauchy's theorem: a finite group has an element of order p for every prime p dividing its size", "answer": "exists_prime_orderOf_dvd_card.{u_3} {G : Type u_3} [Group G] [Fintype G] (p : ℕ) [hp : Fact (Nat.Prime p)] (hdvd : p ∣ Fintype.card G) : ∃ x, orderOf x = p", "how": "lean", "source": "mathlib", "theorem": "exists_prime_orderOf_dvd_card", "added": "2026-10-29", "proof": "Lean theorem exists_prime_orderOf_dvd_card from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m60", "rung": 0, "claim": "Counting two sets: the union plus the overlap equals the two sizes added", "answer": "Finset.card_union_add_card_inter.{u_1} {α : Type u_1} [DecidableEq α] (s t : Finset α) : (s ∪ t).card + (s ∩ t).card = s.card + t.card", "how": "lean", "source": "mathlib", "theorem": "Finset.card_union_add_card_inter", "added": "2026-10-29", "proof": "Lean theorem Finset.card_union_add_card_inter from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m61", "rung": 0, "claim": "The number of ways to shuffle so nothing stays in place follows the derangement formula", "answer": "card_derangements_eq_numDerangements.{u_2} (α : Type u_2) [Fintype α] [DecidableEq α] : Fintype.card ↑(derangements α) = numDerangements (Fintype.card α)", "how": "lean", "source": "mathlib", "theorem": "card_derangements_eq_numDerangements", "added": "2026-10-29", "proof": "Lean theorem card_derangements_eq_numDerangements from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m62", "rung": 0, "claim": "Hall's marriage theorem", "answer": "Finset.all_card_le_biUnion_card_iff_exists_injective.{u, v} {ι : Type u} {α : Type v} [DecidableEq α] (t : ι → Finset α) : (∀ (s : Finset ι), s.card ≤ (s.biUnion t).card) ↔ ∃ f, Function.Injective f ∧ ∀ (x : ι), f x ∈ t x", "how": "lean", "source": "mathlib", "theorem": "Finset.all_card_le_biUnion_card_iff_exists_injective", "added": "2026-10-29", "proof": "Lean theorem Finset.all_card_le_biUnion_card_iff_exists_injective from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m63", "rung": 0, "claim": "Bolzano-Weierstrass: every bounded sequence has a convergent subsequence", "answer": "tendsto_subseq_of_bounded.{u_1} {X : Type u_1} [PseudoMetricSpace X] [ProperSpace X] {s : Set X} (hs : Bornology.IsBounded s) {x : ℕ → X} (hx : ∀ (n : ℕ), x n ∈ s) : ∃ a ∈ closure s, ∃ φ, StrictMono φ ∧ Filter.Tendsto (x ∘ φ) Filter.atTop (nhds a)", "how": "lean", "source": "mathlib", "theorem": "tendsto_subseq_of_bounded", "added": "2026-10-29", "proof": "Lean theorem tendsto_subseq_of_bounded from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m64", "rung": 0, "claim": "e to any real power is always positive", "answer": "Real.exp_pos (x : ℝ) : 0 < Real.exp x", "how": "lean", "source": "mathlib", "theorem": "Real.exp_pos", "added": "2026-10-29", "proof": "Lean theorem Real.exp_pos from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m65", "rung": 0, "claim": "The log of a product is the sum of the logs", "answer": "Real.log_mul {x y : ℝ} (hx : x ≠ 0) (hy : y ≠ 0) : Real.log (x * y) = Real.log x + Real.log y", "how": "lean", "source": "mathlib", "theorem": "Real.log_mul", "added": "2026-10-29", "proof": "Lean theorem Real.log_mul from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "m66", "rung": 0, "claim": "The fundamental theorem of arithmetic: a number breaks into primes in only one way", "answer": "UniqueFactorizationMonoid.factors_unique.{u_1} {α : Type u_1} [CommMonoidWithZero α] [UniqueFactorizationMonoid α] {f g : Multiset α} (hf : ∀ x ∈ f, Irreducible x) (hg : ∀ x ∈ g, Irreducible x) (h : Associated f.prod g.prod) : Multiset.Rel Associated f g", "how": "lean", "source": "mathlib", "theorem": "UniqueFactorizationMonoid.factors_unique", "added": "2026-10-29", "proof": "Lean theorem UniqueFactorizationMonoid.factors_unique from Mathlib, the shared library of checked math built by hundreds of people; Lean found it and accepted it on our computer while this map was made, resting only on Lean's standard axioms.", "notProven": "Lean checks the statement shown above, not the plain English line, which a person wrote to match it." }, { "id": "c0", "rung": 4, "claim": "Roast an unstuffed 12 lb turkey at 325°F (163°C)", "form": "(325 - 32) * 5 / 9 ~= 163", "how": "lean", "check": "rounded", "question": "How long should I cook a 12 pound turkey, and at what temperature?", "proof": "Lean theorem Checked.fact_93037ba0b0 (LeanProofs/Checked.lean) states exactly what the browser checker checks here, over exact fractions; it builds with no sorry and rests only on Lean's standard axioms. The browser checker re-ran it while this map was made: exact value 162.777777778; the answer said 163, which allows up to 0.5 either way.", "notProven": "Only the numbers in it are proven (the arithmetic, the rounding, the unit conversion), not the measured fact they describe.", "source": "checked", "theorem": "Checked.fact_93037ba0b0", "answer": "(325 - 32) * 5 / 9 ~= 163", "statement": "((325 : ℚ) / 2) ≤ ((325 : ℚ) - (32 : ℚ)) * (5 : ℚ) / (9 : ℚ) ∧ ((325 : ℚ) - (32 : ℚ)) * (5 : ℚ) / (9 : ℚ) ≤ ((327 : ℚ) / 2)" }, { "id": "c1", "rung": 4, "claim": "The time is only a guide; the turkey is done when a meat thermometer reads 165°F (74°C)", "form": "(165 - 32) * 5 / 9 ~= 74", "how": "lean", "check": "rounded", "question": "How long should I cook a 12 pound turkey, and at what temperature?", "proof": "Lean theorem Checked.fact_1b582937ca (LeanProofs/Checked.lean) states exactly what the browser checker checks here, over exact fractions; it builds with no sorry and rests only on Lean's standard axioms. The browser checker re-ran it while this map was made: exact value 73.8888888889; the answer said 74, which allows up to 0.5 either way.", "notProven": "Only the numbers in it are proven (the arithmetic, the rounding, the unit conversion), not the measured fact they describe.", "source": "checked", "theorem": "Checked.fact_1b582937ca", "answer": "(165 - 32) * 5 / 9 ~= 74", "statement": "((147 : ℚ) / 2) ≤ ((165 : ℚ) - (32 : ℚ)) * (5 : ℚ) / (9 : ℚ) ∧ ((165 : ℚ) - (32 : ℚ)) * (5 : ℚ) / (9 : ℚ) ≤ ((149 : ℚ) / 2)" }, { "id": "c2", "rung": 0, "claim": "2^31 - 1 = 2,147,483,647", "form": "2^31 - 1 = 2147483647", "how": "lean", "check": "math", "question": "Is 2^31 - 1 a prime number? Explain briefly.", "proof": "Lean theorem Checked.fact_34bb651c45 (LeanProofs/Checked.lean) states exactly what the browser checker checks here, over exact fractions; it builds with no sorry and rests only on Lean's standard axioms. The browser checker re-ran it while this map was made: exact fractions: left is 2147483647, right is 2147483647.", "notProven": "", "source": "checked", "theorem": "Checked.fact_34bb651c45", "answer": "2^31 - 1 = 2147483647", "statement": "(2 : ℚ) ^ 31 - (1 : ℚ) = (2147483647 : ℚ)" }, { "id": "c3", "rung": 0, "claim": "2^31 - 1 is prime", "form": "2^31 - 1 is prime", "how": "lean", "check": "prime", "question": "Is 2^31 - 1 a prime number? Explain briefly.", "proof": "Lean theorem Checked.fact_b5d080bd5b (LeanProofs/Checked.lean) states exactly what the browser checker checks here, over exact fractions; it builds with no sorry and rests only on Lean's standard axioms. The browser checker re-ran it while this map was made: 2147483647 is prime.", "notProven": "", "source": "checked", "theorem": "Checked.fact_b5d080bd5b", "answer": "2^31 - 1 is prime", "statement": "Nat.Prime (2^31 - 1 : ℕ)" }, { "id": "c4", "rung": 0, "claim": "31 is prime", "form": "31 is prime", "how": "lean", "check": "prime", "question": "Is 2^31 - 1 a prime number? Explain briefly.", "proof": "Lean theorem Checked.fact_312af59383 (LeanProofs/Checked.lean) states exactly what the browser checker checks here, over exact fractions; it builds with no sorry and rests only on Lean's standard axioms. The browser checker re-ran it while this map was made: 31 is prime.", "notProven": "", "source": "checked", "theorem": "Checked.fact_312af59383", "answer": "31 is prime", "statement": "Nat.Prime (31 : ℕ)" }, { "id": "c5", "rung": 0, "claim": "2^11 - 1 = 2047", "form": "2^11 - 1 = 2047", "how": "lean", "check": "math", "question": "Is 2^31 - 1 a prime number? Explain briefly.", "proof": "Lean theorem Checked.fact_c644418975 (LeanProofs/Checked.lean) states exactly what the browser checker checks here, over exact fractions; it builds with no sorry and rests only on Lean's standard axioms. The browser checker re-ran it while this map was made: exact fractions: left is 2047, right is 2047.", "notProven": "", "source": "checked", "theorem": "Checked.fact_c644418975", "answer": "2^11 - 1 = 2047", "statement": "(2 : ℚ) ^ 11 - (1 : ℚ) = (2047 : ℚ)" }, { "id": "c6", "rung": 0, "claim": "2047 = 23 × 89", "form": "23 * 89 = 2047", "how": "lean", "check": "math", "question": "Is 2^31 - 1 a prime number? Explain briefly.", "proof": "Lean theorem Checked.fact_3a8141b546 (LeanProofs/Checked.lean) states exactly what the browser checker checks here, over exact fractions; it builds with no sorry and rests only on Lean's standard axioms. The browser checker re-ran it while this map was made: exact fractions: left is 2047, right is 2047.", "notProven": "", "source": "checked", "theorem": "Checked.fact_3a8141b546", "answer": "23 * 89 = 2047", "statement": "(23 : ℚ) * (89 : ℚ) = (2047 : ℚ)" }, { "id": "c7", "rung": 0, "claim": "2047 is not prime (2^11 - 1 fails)", "form": "2047 is not prime", "how": "lean", "check": "prime", "question": "Is 2^31 - 1 a prime number? Explain briefly.", "proof": "Lean theorem Checked.fact_80343816ea (LeanProofs/Checked.lean) states exactly what the browser checker checks here, over exact fractions; it builds with no sorry and rests only on Lean's standard axioms. The browser checker re-ran it while this map was made: 2047 is not prime: 23 x 89 = 2047.", "notProven": "", "source": "checked", "theorem": "Checked.fact_80343816ea", "answer": "2047 is not prime", "statement": "¬ Nat.Prime (2047 : ℕ)" }, { "id": "c8", "rung": 0, "claim": "The square root of 2^31 - 1 is about 46,341", "form": "2147483647^(1/2) ~= 46341", "how": "lean", "check": "rounded", "question": "Is 2^31 - 1 a prime number? Explain briefly.", "proof": "Lean theorem Checked.fact_d67c9c2c3d (LeanProofs/Checked.lean) states exactly what the browser checker checks here, over exact fractions; it builds with no sorry and rests only on Lean's standard axioms. The browser checker re-ran it while this map was made: exact value about 46340.9500011; the answer said 46341, which allows up to 0.5 either way.", "notProven": "Only the numbers in it are proven (the arithmetic, the rounding, the unit conversion), not the measured fact they describe.", "source": "checked", "theorem": "Checked.fact_d67c9c2c3d", "answer": "2147483647^(1/2) ~= 46341", "statement": "92681/2 ≤ Real.sqrt 2147483647 ∧ Real.sqrt 2147483647 ≤ 92683/2" }, { "id": "c9", "rung": 4, "claim": "2.7 liters is roughly 11 cups", "form": "2.7 / 0.2365882365 ~= 11", "how": "lean", "check": "rounded", "question": "How much water should an adult drink per day?", "proof": "Lean theorem Checked.fact_43bbfa7405 (LeanProofs/Checked.lean) states exactly what the browser checker checks here, over exact fractions; it builds with no sorry and rests only on Lean's standard axioms. The browser checker re-ran it while this map was made: exact value 11.4122326619; the answer said 11, which allows up to 0.5 either way.", "notProven": "Only the numbers in it are proven (the arithmetic, the rounding, the unit conversion), not the measured fact they describe.", "source": "checked", "theorem": "Checked.fact_43bbfa7405", "answer": "2.7 / 0.2365882365 ~= 11", "statement": "((21 : ℚ) / 2) ≤ ((27 : ℚ) / 10) / ((473176473 : ℚ) / 2000000000) ∧ ((27 : ℚ) / 10) / ((473176473 : ℚ) / 2000000000) ≤ ((23 : ℚ) / 2)" }, { "id": "c10", "rung": 4, "claim": "With annual compounding, $10,000 at 7% for 10 years grows to about $19,671.51", "form": "10000 * 1.07^10 ~= 19671.51", "how": "lean", "check": "rounded", "question": "If I invest $10,000 at 7% a year for 10 years, how much will I have?", "proof": "Lean theorem Checked.fact_63ff73722c (LeanProofs/Checked.lean) states exactly what the browser checker checks here, over exact fractions; it builds with no sorry and rests only on Lean's standard axioms. The browser checker re-ran it while this map was made: exact value 19671.5135729; the answer said 19671.51, which allows up to 0.005 either way.", "notProven": "Only the numbers in it are proven (the arithmetic, the rounding, the unit conversion), not the measured fact they describe.", "source": "checked", "theorem": "Checked.fact_63ff73722c", "answer": "10000 * 1.07^10 ~= 19671.51", "statement": "((3934301 : ℚ) / 200) ≤ (10000 : ℚ) * ((107 : ℚ) / 100) ^ 10 ∧ (10000 : ℚ) * ((107 : ℚ) / 100) ^ 10 ≤ ((3934303 : ℚ) / 200)" }, { "id": "c11", "rung": 4, "claim": "That's a gain of roughly $9,672", "form": "19671.51 - 10000 ~= 9672", "how": "lean", "check": "rounded", "question": "If I invest $10,000 at 7% a year for 10 years, how much will I have?", "proof": "Lean theorem Checked.fact_9e39028ab6 (LeanProofs/Checked.lean) states exactly what the browser checker checks here, over exact fractions; it builds with no sorry and rests only on Lean's standard axioms. The browser checker re-ran it while this map was made: exact value 9671.51; the answer said 9672, which allows up to 0.5 either way.", "notProven": "Only the numbers in it are proven (the arithmetic, the rounding, the unit conversion), not the measured fact they describe.", "source": "checked", "theorem": "Checked.fact_9e39028ab6", "answer": "19671.51 - 10000 ~= 9672", "statement": "((19343 : ℚ) / 2) ≤ ((1967151 : ℚ) / 100) - (10000 : ℚ) ∧ ((1967151 : ℚ) / 100) - (10000 : ℚ) ≤ ((19345 : ℚ) / 2)" }, { "id": "c12", "rung": 4, "claim": "If interest compounds monthly instead, you'd end up with about $20,097", "form": "10000 * (1 + 0.07 / 12)^120 ~= 20097", "how": "lean", "check": "rounded", "question": "If I invest $10,000 at 7% a year for 10 years, how much will I have?", "proof": "Lean theorem Checked.fact_fcdb5f37fe (LeanProofs/Checked.lean) states exactly what the browser checker checks here, over exact fractions; it builds with no sorry and rests only on Lean's standard axioms. The browser checker re-ran it while this map was made: exact value NaN; the answer said 20097, which allows up to 0.5 either way.", "notProven": "Only the numbers in it are proven (the arithmetic, the rounding, the unit conversion), not the measured fact they describe.", "source": "checked", "theorem": "Checked.fact_fcdb5f37fe", "answer": "10000 * (1 + 0.07 / 12)^120 ~= 20097", "statement": "((40193 : ℚ) / 2) ≤ (10000 : ℚ) * ((1 : ℚ) + ((7 : ℚ) / 100) / (12 : ℚ)) ^ 120 ∧ (10000 : ℚ) * ((1 : ℚ) + ((7 : ℚ) / 100) / (12 : ℚ)) ^ 120 ≤ ((40195 : ℚ) / 2)" }, { "id": "c13", "rung": 6, "claim": "299,792,458 m/s is about 300,000 km/s", "form": "c / 1000 ~= 300000", "how": "lean", "check": "defined", "question": "What is the speed of light, and how long does light take to reach us from the Moon?", "proof": "Lean theorem Checked.fact_97722815d6 (LeanProofs/Checked.lean) states exactly what the browser checker checks here, over exact fractions; it builds with no sorry and rests only on Lean's standard axioms. The browser checker re-ran it while this map was made: exact value 299792.458; the answer said 300000, which allows up to 50000 either way.", "notProven": "Only the numbers in it are proven (the arithmetic, the rounding, the unit conversion), not the measured fact they describe.", "source": "checked", "theorem": "Checked.fact_97722815d6", "answer": "c / 1000 ~= 300000", "statement": "(250000 : ℚ) ≤ (299792458 : ℚ) / (1000 : ℚ) ∧ (299792458 : ℚ) / (1000 : ℚ) ≤ (350000 : ℚ)" }, { "id": "c14", "rung": 6, "claim": "that is about 186,282 miles/s", "form": "c / mile ~= 186282", "how": "lean", "check": "defined", "question": "What is the speed of light, and how long does light take to reach us from the Moon?", "proof": "Lean theorem Checked.fact_c5f17bbea5 (LeanProofs/Checked.lean) states exactly what the browser checker checks here, over exact fractions; it builds with no sorry and rests only on Lean's standard axioms. The browser checker re-ran it while this map was made: exact value 186282.397051; the answer said 186282, which allows up to 0.5 either way.", "notProven": "Only the numbers in it are proven (the arithmetic, the rounding, the unit conversion), not the measured fact they describe.", "source": "checked", "theorem": "Checked.fact_c5f17bbea5", "answer": "c / mile ~= 186282", "statement": "((372563 : ℚ) / 2) ≤ (299792458 : ℚ) / ((201168 : ℚ) / 125) ∧ (299792458 : ℚ) / ((201168 : ℚ) / 125) ≤ ((372565 : ℚ) / 2)" }, { "id": "c15", "rung": 6, "claim": "light takes roughly 1.3 seconds to get from the Moon to us", "form": "384400000 / c ~= 1.3", "how": "lean", "check": "defined", "question": "What is the speed of light, and how long does light take to reach us from the Moon?", "proof": "Lean theorem Checked.fact_0408b364e3 (LeanProofs/Checked.lean) states exactly what the browser checker checks here, over exact fractions; it builds with no sorry and rests only on Lean's standard axioms. The browser checker re-ran it while this map was made: exact value 1.28222038194; the answer said 1.3, which allows up to 0.05 either way.", "notProven": "Only the numbers in it are proven (the arithmetic, the rounding, the unit conversion), not the measured fact they describe.", "source": "checked", "theorem": "Checked.fact_0408b364e3", "answer": "384400000 / c ~= 1.3", "statement": "((5 : ℚ) / 4) ≤ (384400000 : ℚ) / (299792458 : ℚ) ∧ (384400000 : ℚ) / (299792458 : ℚ) ≤ ((27 : ℚ) / 20)" }, { "id": "c16", "rung": 0, "claim": "2^100 is bigger (than 10^30)", "form": "2^100 > 10^30", "how": "lean", "check": "math", "question": "Which is bigger, 2^100 or 10^30? Show the reasoning.", "proof": "Lean theorem Checked.fact_7258aa51ff (LeanProofs/Checked.lean) states exactly what the browser checker checks here, over exact fractions; it builds with no sorry and rests only on Lean's standard axioms. The browser checker re-ran it while this map was made: exact fractions: left is 1267650600228229401496703205376, right is 1000000000000000000000000000000.", "notProven": "", "source": "checked", "theorem": "Checked.fact_7258aa51ff", "answer": "2^100 > 10^30", "statement": "(2 : ℚ) ^ 100 > (10 : ℚ) ^ 30" }, { "id": "c17", "rung": 0, "claim": "2^10 = 1024", "form": "2^10 = 1024", "how": "lean", "check": "math", "question": "Which is bigger, 2^100 or 10^30? Show the reasoning.", "proof": "Lean theorem Checked.fact_1702a99383 (LeanProofs/Checked.lean) states exactly what the browser checker checks here, over exact fractions; it builds with no sorry and rests only on Lean's standard axioms. The browser checker re-ran it while this map was made: exact fractions: left is 1024, right is 1024.", "notProven": "", "source": "checked", "theorem": "Checked.fact_1702a99383", "answer": "2^10 = 1024", "statement": "(2 : ℚ) ^ 10 = (1024 : ℚ)" }, { "id": "c18", "rung": 0, "claim": "1024 is slightly more than 10^3", "form": "2^10 > 10^3", "how": "lean", "check": "math", "question": "Which is bigger, 2^100 or 10^30? Show the reasoning.", "proof": "Lean theorem Checked.fact_9aa214201b (LeanProofs/Checked.lean) states exactly what the browser checker checks here, over exact fractions; it builds with no sorry and rests only on Lean's standard axioms. The browser checker re-ran it while this map was made: exact fractions: left is 1024, right is 1000.", "notProven": "", "source": "checked", "theorem": "Checked.fact_9aa214201b", "answer": "2^10 > 10^3", "statement": "(2 : ℚ) ^ 10 > (10 : ℚ) ^ 3" }, { "id": "c19", "rung": 0, "claim": "2^100 = (2^10)^10", "form": "2^100 = (2^10)^10", "how": "lean", "check": "math", "question": "Which is bigger, 2^100 or 10^30? Show the reasoning.", "proof": "Lean theorem Checked.fact_52bf7960c3 (LeanProofs/Checked.lean) states exactly what the browser checker checks here, over exact fractions; it builds with no sorry and rests only on Lean's standard axioms. The browser checker re-ran it while this map was made: exact fractions: left is 1267650600228229401496703205376, right is 1267650600228229401496703205376.", "notProven": "", "source": "checked", "theorem": "Checked.fact_52bf7960c3", "answer": "2^100 = (2^10)^10", "statement": "(2 : ℚ) ^ 100 = ((2 : ℚ) ^ 10) ^ 10" }, { "id": "c20", "rung": 0, "claim": "(2^10)^10 > (10^3)^10", "form": "(2^10)^10 > (10^3)^10", "how": "lean", "check": "math", "question": "Which is bigger, 2^100 or 10^30? Show the reasoning.", "proof": "Lean theorem Checked.fact_013633654f (LeanProofs/Checked.lean) states exactly what the browser checker checks here, over exact fractions; it builds with no sorry and rests only on Lean's standard axioms. The browser checker re-ran it while this map was made: exact fractions: left is 1267650600228229401496703205376, right is 1000000000000000000000000000000.", "notProven": "", "source": "checked", "theorem": "Checked.fact_013633654f", "answer": "(2^10)^10 > (10^3)^10", "statement": "((2 : ℚ) ^ 10) ^ 10 > ((10 : ℚ) ^ 3) ^ 10" }, { "id": "c21", "rung": 0, "claim": "(10^3)^10 = 10^30", "form": "(10^3)^10 = 10^30", "how": "lean", "check": "math", "question": "Which is bigger, 2^100 or 10^30? Show the reasoning.", "proof": "Lean theorem Checked.fact_9b91ccd4cd (LeanProofs/Checked.lean) states exactly what the browser checker checks here, over exact fractions; it builds with no sorry and rests only on Lean's standard axioms. The browser checker re-ran it while this map was made: exact fractions: left is 1000000000000000000000000000000, right is 1000000000000000000000000000000.", "notProven": "", "source": "checked", "theorem": "Checked.fact_9b91ccd4cd", "answer": "(10^3)^10 = 10^30", "statement": "((10 : ℚ) ^ 3) ^ 10 = (10 : ℚ) ^ 30" }, { "id": "c22", "rung": 0, "claim": "2^100 ≈ 1.2677 × 10^30", "form": "2^100 ~= 1.2677 * 10^30", "how": "lean", "check": "rounded", "question": "Which is bigger, 2^100 or 10^30? Show the reasoning.", "proof": "Lean theorem Checked.fact_3c5f43f4be (LeanProofs/Checked.lean) states exactly what the browser checker checks here, over exact fractions; it builds with no sorry and rests only on Lean's standard axioms. The browser checker re-ran it while this map was made: exact value 1267650600228229401496703205376; the answer said 1267700000000000000000000000000, which allows up to 50000000000000000000000000 either way.", "notProven": "Only the numbers in it are proven (the arithmetic, the rounding, the unit conversion), not the measured fact they describe.", "source": "checked", "theorem": "Checked.fact_3c5f43f4be", "answer": "2^100 ~= 1.2677 * 10^30", "statement": "(1267650000000000000000000000000 : ℚ) ≤ (2 : ℚ) ^ 100 ∧ (2 : ℚ) ^ 100 ≤ (1267750000000000000000000000000 : ℚ)" }, { "id": "c23", "rung": 0, "claim": "2^100 exceeds 10^30 by about 27%", "form": "(2^100 - 10^30) / 10^30 ~= 0.27", "how": "lean", "check": "rounded", "question": "Which is bigger, 2^100 or 10^30? Show the reasoning.", "proof": "Lean theorem Checked.fact_3ca05c76a2 (LeanProofs/Checked.lean) states exactly what the browser checker checks here, over exact fractions; it builds with no sorry and rests only on Lean's standard axioms. The browser checker re-ran it while this map was made: exact value 0.267650600228; the answer said 0.27, which allows up to 0.005 either way.", "notProven": "Only the numbers in it are proven (the arithmetic, the rounding, the unit conversion), not the measured fact they describe.", "source": "checked", "theorem": "Checked.fact_3ca05c76a2", "answer": "(2^100 - 10^30) / 10^30 ~= 0.27", "statement": "((53 : ℚ) / 200) ≤ ((2 : ℚ) ^ 100 - (10 : ℚ) ^ 30) / (10 : ℚ) ^ 30 ∧ ((2 : ℚ) ^ 100 - (10 : ℚ) ^ 30) / (10 : ℚ) ^ 30 ≤ ((11 : ℚ) / 40)" }, { "id": "c24", "rung": 5, "claim": "8,848.86 meters is 29,031.7 feet", "form": "8848.86 / 0.3048 ~= 29031.7", "how": "lean", "check": "rounded", "question": "What is the tallest mountain in the world and how tall is it?", "proof": "Lean theorem Checked.fact_0513c316ec (LeanProofs/Checked.lean) states exactly what the browser checker checks here, over exact fractions; it builds with no sorry and rests only on Lean's standard axioms. The browser checker re-ran it while this map was made: exact value 29031.6929134; the answer said 29031.7, which allows up to 0.05 either way.", "notProven": "Only the numbers in it are proven (the arithmetic, the rounding, the unit conversion), not the measured fact they describe.", "source": "checked", "theorem": "Checked.fact_0513c316ec", "answer": "8848.86 / 0.3048 ~= 29031.7", "statement": "((580633 : ℚ) / 20) ≤ ((442443 : ℚ) / 50) / ((381 : ℚ) / 1250) ∧ ((442443 : ℚ) / 50) / ((381 : ℚ) / 1250) ≤ ((116127 : ℚ) / 4)" }, { "id": "c25", "rung": 6, "claim": "The Sun is about 149.6 million kilometers from Earth on average", "form": "au / 1000 ~= 149600000", "how": "lean", "check": "defined", "question": "How far is the Sun from Earth, and how long does sunlight take to get here?", "proof": "Lean theorem Checked.fact_b29cd928ac (LeanProofs/Checked.lean) states exactly what the browser checker checks here, over exact fractions; it builds with no sorry and rests only on Lean's standard axioms. The browser checker re-ran it while this map was made: exact value 149597870.7; the answer said 149600000, which allows up to 50000 either way.", "notProven": "Only the numbers in it are proven (the arithmetic, the rounding, the unit conversion), not the measured fact they describe.", "source": "checked", "theorem": "Checked.fact_b29cd928ac", "answer": "au / 1000 ~= 149600000", "statement": "(149550000 : ℚ) ≤ (149597870700 : ℚ) / (1000 : ℚ) ∧ (149597870700 : ℚ) / (1000 : ℚ) ≤ (149650000 : ℚ)" }, { "id": "c26", "rung": 6, "claim": "The Sun is about 93 million miles from Earth on average", "form": "au / mile ~= 93000000", "how": "lean", "check": "defined", "question": "How far is the Sun from Earth, and how long does sunlight take to get here?", "proof": "Lean theorem Checked.fact_6558b4c522 (LeanProofs/Checked.lean) states exactly what the browser checker checks here, over exact fractions; it builds with no sorry and rests only on Lean's standard axioms. The browser checker re-ran it while this map was made: exact value 92955807.273; the answer said 93000000, which allows up to 500000 either way.", "notProven": "Only the numbers in it are proven (the arithmetic, the rounding, the unit conversion), not the measured fact they describe.", "source": "checked", "theorem": "Checked.fact_6558b4c522", "answer": "au / mile ~= 93000000", "statement": "(92500000 : ℚ) ≤ (149597870700 : ℚ) / ((201168 : ℚ) / 125) ∧ (149597870700 : ℚ) / ((201168 : ℚ) / 125) ≤ (93500000 : ℚ)" }, { "id": "c27", "rung": 2, "claim": "100 °C is 212 °F", "form": "(100 * 9 / 5) + 32 = 212", "how": "lean", "check": "math", "question": "What is the boiling point of water at sea level in Fahrenheit and Celsius?", "proof": "Lean theorem Checked.fact_39937949b1 (LeanProofs/Checked.lean) states exactly what the browser checker checks here, over exact fractions; it builds with no sorry and rests only on Lean's standard axioms. The browser checker re-ran it while this map was made: exact fractions: left is 212, right is 212.", "notProven": "", "source": "checked", "theorem": "Checked.fact_39937949b1", "answer": "(100 * 9 / 5) + 32 = 212", "statement": "((100 : ℚ) * (9 : ℚ) / (5 : ℚ)) + (32 : ℚ) = (212 : ℚ)" }, { "id": "c28", "rung": 5, "claim": "65 mph × 3.5 hours = 227.5 miles", "form": "65 * 3.5 = 227.5", "how": "lean", "check": "math", "question": "If a car goes 65 miles per hour for 3.5 hours, how far does it go, in miles and kilometers?", "proof": "Lean theorem Checked.fact_fadd39bffc (LeanProofs/Checked.lean) states exactly what the browser checker checks here, over exact fractions; it builds with no sorry and rests only on Lean's standard axioms. The browser checker re-ran it while this map was made: exact fractions: left is 227.5, right is 227.5.", "notProven": "", "source": "checked", "theorem": "Checked.fact_fadd39bffc", "answer": "65 * 3.5 = 227.5", "statement": "(65 : ℚ) * ((7 : ℚ) / 2) = ((455 : ℚ) / 2)" }, { "id": "c29", "rung": 5, "claim": "227.5 miles is about 366.1 kilometers", "form": "227.5 * 1.609344 ~= 366.1", "how": "lean", "check": "rounded", "question": "If a car goes 65 miles per hour for 3.5 hours, how far does it go, in miles and kilometers?", "proof": "Lean theorem Checked.fact_9ca9a0e24b (LeanProofs/Checked.lean) states exactly what the browser checker checks here, over exact fractions; it builds with no sorry and rests only on Lean's standard axioms. The browser checker re-ran it while this map was made: exact value 366.12576; the answer said 366.1, which allows up to 0.05 either way.", "notProven": "Only the numbers in it are proven (the arithmetic, the rounding, the unit conversion), not the measured fact they describe.", "source": "checked", "theorem": "Checked.fact_9ca9a0e24b", "answer": "227.5 * 1.609344 ~= 366.1", "statement": "((7321 : ℚ) / 20) ≤ ((455 : ℚ) / 2) * ((25146 : ℚ) / 15625) ∧ ((455 : ℚ) / 2) * ((25146 : ℚ) / 15625) ≤ ((7323 : ℚ) / 20)" }, { "id": "c30", "rung": 5, "claim": "A day has 86,400 seconds", "form": "86400 = 24 * 60 * 60", "how": "lean", "check": "math", "question": "How many seconds are in a day, and in a year?", "proof": "Lean theorem Checked.fact_075d9c7407 (LeanProofs/Checked.lean) states exactly what the browser checker checks here, over exact fractions; it builds with no sorry and rests only on Lean's standard axioms. The browser checker re-ran it while this map was made: exact fractions: left is 86400, right is 86400.", "notProven": "", "source": "checked", "theorem": "Checked.fact_075d9c7407", "answer": "86400 = 24 * 60 * 60", "statement": "(86400 : ℚ) = (24 : ℚ) * (60 : ℚ) * (60 : ℚ)" }, { "id": "c31", "rung": 5, "claim": "24 × 60 × 60 equals 86,400", "form": "24 * 60 * 60 = 86400", "how": "lean", "check": "math", "question": "How many seconds are in a day, and in a year?", "proof": "Lean theorem Checked.fact_a56a2971f6 (LeanProofs/Checked.lean) states exactly what the browser checker checks here, over exact fractions; it builds with no sorry and rests only on Lean's standard axioms. The browser checker re-ran it while this map was made: exact fractions: left is 86400, right is 86400.", "notProven": "", "source": "checked", "theorem": "Checked.fact_a56a2971f6", "answer": "24 * 60 * 60 = 86400", "statement": "(24 : ℚ) * (60 : ℚ) * (60 : ℚ) = (86400 : ℚ)" }, { "id": "c32", "rung": 5, "claim": "A standard 365-day year has 31,536,000 seconds", "form": "365 * 86400 = 31536000", "how": "lean", "check": "math", "question": "How many seconds are in a day, and in a year?", "proof": "Lean theorem Checked.fact_1bee5d9801 (LeanProofs/Checked.lean) states exactly what the browser checker checks here, over exact fractions; it builds with no sorry and rests only on Lean's standard axioms. The browser checker re-ran it while this map was made: exact fractions: left is 31536000, right is 31536000.", "notProven": "", "source": "checked", "theorem": "Checked.fact_1bee5d9801", "answer": "365 * 86400 = 31536000", "statement": "(365 : ℚ) * (86400 : ℚ) = (31536000 : ℚ)" }, { "id": "c33", "rung": 5, "claim": "A leap year (366 days) has 31,622,400 seconds", "form": "366 * 86400 = 31622400", "how": "lean", "check": "math", "question": "How many seconds are in a day, and in a year?", "proof": "Lean theorem Checked.fact_e552d5a370 (LeanProofs/Checked.lean) states exactly what the browser checker checks here, over exact fractions; it builds with no sorry and rests only on Lean's standard axioms. The browser checker re-ran it while this map was made: exact fractions: left is 31622400, right is 31622400.", "notProven": "", "source": "checked", "theorem": "Checked.fact_e552d5a370", "answer": "366 * 86400 = 31622400", "statement": "(366 : ℚ) * (86400 : ℚ) = (31622400 : ℚ)" }, { "id": "c34", "rung": 5, "claim": "The Gregorian calendar year works out to about 31,556,952 seconds", "form": "365.2425 * 86400 ~= 31556952", "how": "lean", "check": "rounded", "question": "How many seconds are in a day, and in a year?", "proof": "Lean theorem Checked.fact_3cc938df76 (LeanProofs/Checked.lean) states exactly what the browser checker checks here, over exact fractions; it builds with no sorry and rests only on Lean's standard axioms. The browser checker re-ran it while this map was made: exact value 31556952; the answer said 31556952, which allows up to 0.5 either way.", "notProven": "Only the numbers in it are proven (the arithmetic, the rounding, the unit conversion), not the measured fact they describe.", "source": "checked", "theorem": "Checked.fact_3cc938df76", "answer": "365.2425 * 86400 ~= 31556952", "statement": "((63113903 : ℚ) / 2) ≤ ((146097 : ℚ) / 400) * (86400 : ℚ) ∧ ((146097 : ℚ) / 400) * (86400 : ℚ) ≤ ((63113905 : ℚ) / 2)" }, { "id": "c35", "rung": 5, "claim": "roughly 64 million square miles", "form": "165000000 / 1.609344^2 ~= 64000000", "how": "lean", "check": "rounded", "question": "What is the largest ocean on Earth and how big is it?", "proof": "Lean theorem Checked.fact_0b44015d6d (LeanProofs/Checked.lean) states exactly what the browser checker checks here, over exact fractions; it builds with no sorry and rests only on Lean's standard axioms. The browser checker re-ran it while this map was made: exact value 63706856.1595; the answer said 64000000, which allows up to 500000 either way.", "notProven": "Only the numbers in it are proven (the arithmetic, the rounding, the unit conversion), not the measured fact they describe.", "source": "checked", "theorem": "Checked.fact_0b44015d6d", "answer": "165000000 / 1.609344^2 ~= 64000000", "statement": "(63500000 : ℚ) ≤ (165000000 : ℚ) / ((25146 : ℚ) / 15625) ^ 2 ∧ (165000000 : ℚ) / ((25146 : ℚ) / 15625) ^ 2 ≤ (64500000 : ℚ)" }, { "id": "c36", "rung": 5, "claim": "4,000 meters is about 13,000 feet", "form": "4000 / 0.3048 ~= 13000", "how": "lean", "check": "rounded", "question": "What is the largest ocean on Earth and how big is it?", "proof": "Lean theorem Checked.fact_7e36616bb7 (LeanProofs/Checked.lean) states exactly what the browser checker checks here, over exact fractions; it builds with no sorry and rests only on Lean's standard axioms. The browser checker re-ran it while this map was made: exact value 13123.3595801; the answer said 13000, which allows up to 500 either way.", "notProven": "Only the numbers in it are proven (the arithmetic, the rounding, the unit conversion), not the measured fact they describe.", "source": "checked", "theorem": "Checked.fact_7e36616bb7", "answer": "4000 / 0.3048 ~= 13000", "statement": "(12500 : ℚ) ≤ (4000 : ℚ) / ((381 : ℚ) / 1250) ∧ (4000 : ℚ) / ((381 : ℚ) / 1250) ≤ (13500 : ℚ)" }, { "id": "c37", "rung": 5, "claim": "11,000 meters is about 36,000 feet", "form": "11000 / 0.3048 ~= 36000", "how": "lean", "check": "rounded", "question": "What is the largest ocean on Earth and how big is it?", "proof": "Lean theorem Checked.fact_287ec5269b (LeanProofs/Checked.lean) states exactly what the browser checker checks here, over exact fractions; it builds with no sorry and rests only on Lean's standard axioms. The browser checker re-ran it while this map was made: exact value 36089.2388451; the answer said 36000, which allows up to 500 either way.", "notProven": "Only the numbers in it are proven (the arithmetic, the rounding, the unit conversion), not the measured fact they describe.", "source": "checked", "theorem": "Checked.fact_287ec5269b", "answer": "11000 / 0.3048 ~= 36000", "statement": "(35500 : ℚ) ≤ (11000 : ℚ) / ((381 : ℚ) / 1250) ∧ (11000 : ℚ) / ((381 : ℚ) / 1250) ≤ (36500 : ℚ)" }, { "id": "c38", "rung": 6, "claim": "343 m/s is roughly 1,235 km/h", "form": "343 * 3.6 ~= 1235", "how": "lean", "check": "rounded", "question": "How fast does sound travel in air, and how far away is a storm if thunder comes 5 seconds after lightning?", "proof": "Lean theorem Checked.fact_5937c69a9b (LeanProofs/Checked.lean) states exactly what the browser checker checks here, over exact fractions; it builds with no sorry and rests only on Lean's standard axioms. The browser checker re-ran it while this map was made: exact value 1234.8; the answer said 1235, which allows up to 0.5 either way.", "notProven": "Only the numbers in it are proven (the arithmetic, the rounding, the unit conversion), not the measured fact they describe.", "source": "checked", "theorem": "Checked.fact_5937c69a9b", "answer": "343 * 3.6 ~= 1235", "statement": "((2469 : ℚ) / 2) ≤ (343 : ℚ) * ((18 : ℚ) / 5) ∧ (343 : ℚ) * ((18 : ℚ) / 5) ≤ ((2471 : ℚ) / 2)" }, { "id": "c39", "rung": 6, "claim": "343 m/s is roughly 767 mph", "form": "343 * 3600 / 1609.344 ~= 767", "how": "lean", "check": "rounded", "question": "How fast does sound travel in air, and how far away is a storm if thunder comes 5 seconds after lightning?", "proof": "Lean theorem Checked.fact_4ac5ceac02 (LeanProofs/Checked.lean) states exactly what the browser checker checks here, over exact fractions; it builds with no sorry and rests only on Lean's standard axioms. The browser checker re-ran it while this map was made: exact value 767.269148175; the answer said 767, which allows up to 0.5 either way.", "notProven": "Only the numbers in it are proven (the arithmetic, the rounding, the unit conversion), not the measured fact they describe.", "source": "checked", "theorem": "Checked.fact_4ac5ceac02", "answer": "343 * 3600 / 1609.344 ~= 767", "statement": "((1533 : ℚ) / 2) ≤ (343 : ℚ) * (3600 : ℚ) / ((201168 : ℚ) / 125) ∧ (343 : ℚ) * (3600 : ℚ) / ((201168 : ℚ) / 125) ≤ ((1535 : ℚ) / 2)" }, { "id": "c40", "rung": 6, "claim": "Every 3 seconds of delay is about 1 kilometer", "form": "1000 / 343 ~= 3", "how": "lean", "check": "rounded", "question": "How fast does sound travel in air, and how far away is a storm if thunder comes 5 seconds after lightning?", "proof": "Lean theorem Checked.fact_2c327e50ff (LeanProofs/Checked.lean) states exactly what the browser checker checks here, over exact fractions; it builds with no sorry and rests only on Lean's standard axioms. The browser checker re-ran it while this map was made: exact value 2.91545189504; the answer said 3, which allows up to 0.5 either way.", "notProven": "Only the numbers in it are proven (the arithmetic, the rounding, the unit conversion), not the measured fact they describe.", "source": "checked", "theorem": "Checked.fact_2c327e50ff", "answer": "1000 / 343 ~= 3", "statement": "((5 : ℚ) / 2) ≤ (1000 : ℚ) / (343 : ℚ) ∧ (1000 : ℚ) / (343 : ℚ) ≤ ((7 : ℚ) / 2)" }, { "id": "c41", "rung": 6, "claim": "Every 5 seconds of delay is about 1 mile", "form": "mile / 343 ~= 5", "how": "lean", "check": "defined", "question": "How fast does sound travel in air, and how far away is a storm if thunder comes 5 seconds after lightning?", "proof": "Lean theorem Checked.fact_c759d2f46a (LeanProofs/Checked.lean) states exactly what the browser checker checks here, over exact fractions; it builds with no sorry and rests only on Lean's standard axioms. The browser checker re-ran it while this map was made: exact value 4.69196501458; the answer said 5, which allows up to 0.5 either way.", "notProven": "Only the numbers in it are proven (the arithmetic, the rounding, the unit conversion), not the measured fact they describe.", "source": "checked", "theorem": "Checked.fact_c759d2f46a", "answer": "mile / 343 ~= 5", "statement": "((9 : ℚ) / 2) ≤ ((201168 : ℚ) / 125) / (343 : ℚ) ∧ ((201168 : ℚ) / 125) / (343 : ℚ) ≤ ((11 : ℚ) / 2)" }, { "id": "c42", "rung": 6, "claim": "A 5-second delay puts the lightning about 1.7 km away", "form": "5 * 343 / 1000 ~= 1.7", "how": "lean", "check": "rounded", "question": "How fast does sound travel in air, and how far away is a storm if thunder comes 5 seconds after lightning?", "proof": "Lean theorem Checked.fact_862b60e90c (LeanProofs/Checked.lean) states exactly what the browser checker checks here, over exact fractions; it builds with no sorry and rests only on Lean's standard axioms. The browser checker re-ran it while this map was made: exact value 1.715; the answer said 1.7, which allows up to 0.05 either way.", "notProven": "Only the numbers in it are proven (the arithmetic, the rounding, the unit conversion), not the measured fact they describe.", "source": "checked", "theorem": "Checked.fact_862b60e90c", "answer": "5 * 343 / 1000 ~= 1.7", "statement": "((33 : ℚ) / 20) ≤ (5 : ℚ) * (343 : ℚ) / (1000 : ℚ) ∧ (5 : ℚ) * (343 : ℚ) / (1000 : ℚ) ≤ ((7 : ℚ) / 4)" }, { "id": "c43", "rung": 6, "claim": "A 5-second delay is roughly 1 mile away", "form": "5 * 343 / mile ~= 1", "how": "lean", "check": "defined", "question": "How fast does sound travel in air, and how far away is a storm if thunder comes 5 seconds after lightning?", "proof": "Lean theorem Checked.fact_5ed9eab202 (LeanProofs/Checked.lean) states exactly what the browser checker checks here, over exact fractions; it builds with no sorry and rests only on Lean's standard axioms. The browser checker re-ran it while this map was made: exact value 1.06565159469; the answer said 1, which allows up to 0.5 either way.", "notProven": "Only the numbers in it are proven (the arithmetic, the rounding, the unit conversion), not the measured fact they describe.", "source": "checked", "theorem": "Checked.fact_5ed9eab202", "answer": "5 * 343 / mile ~= 1", "statement": "((1 : ℚ) / 2) ≤ (5 : ℚ) * (343 : ℚ) / ((201168 : ℚ) / 125) ∧ (5 : ℚ) * (343 : ℚ) / ((201168 : ℚ) / 125) ≤ ((3 : ℚ) / 2)" }, { "id": "c44", "rung": 1, "claim": "Two up quarks and one down quark give the proton its charge of exactly +1", "form": "2/3 + 2/3 - 1/3 = 1", "how": "lean", "check": "math", "proof": "Lean theorem Checked.fact_85d8aab008 (LeanProofs/Checked.lean) states exactly what the browser checker checks here, over exact fractions; it builds with no sorry and rests only on Lean's standard axioms. The browser checker re-ran it while this map was made: exact fractions: left is 1, right is 1.", "notProven": "The quark charges (+2/3 and -1/3) are measured physics; only the sum is proven here.", "source": "checked", "theorem": "Checked.fact_85d8aab008", "answer": "2/3 + 2/3 - 1/3 = 1", "statement": "(2 : ℚ) / (3 : ℚ) + (2 : ℚ) / (3 : ℚ) - (1 : ℚ) / (3 : ℚ) = (1 : ℚ)" }, { "id": "c45", "rung": 1, "claim": "One up quark and two down quarks give the neutron a charge of exactly 0", "form": "2/3 - 1/3 - 1/3 = 0", "how": "lean", "check": "math", "proof": "Lean theorem Checked.fact_b22544441d (LeanProofs/Checked.lean) states exactly what the browser checker checks here, over exact fractions; it builds with no sorry and rests only on Lean's standard axioms. The browser checker re-ran it while this map was made: exact fractions: left is 0, right is 0.", "notProven": "The quark charges are measured physics; only the sum is proven here.", "source": "checked", "theorem": "Checked.fact_b22544441d", "answer": "2/3 - 1/3 - 1/3 = 0", "statement": "(2 : ℚ) / (3 : ℚ) - (1 : ℚ) / (3 : ℚ) - (1 : ℚ) / (3 : ℚ) = (0 : ℚ)" }, { "id": "c46", "rung": 7, "claim": "A light-year, the ruler for galaxies, is exactly 9,460,730,472,580,800 meters", "form": "c * year = 9460730472580800", "how": "lean", "check": "defined", "proof": "Lean theorem Checked.fact_06569616c2 (LeanProofs/Checked.lean) states exactly what the browser checker checks here, over exact fractions; it builds with no sorry and rests only on Lean's standard axioms. The browser checker re-ran it while this map was made: exact fractions: left is 9460730472580800, right is 9460730472580800.", "notProven": "This follows from the definitions of the meter, the second and the Julian year; how far any galaxy is, is measured, not proven here.", "source": "checked", "theorem": "Checked.fact_06569616c2", "answer": "c * year = 9460730472580800", "statement": "(299792458 : ℚ) * (31557600 : ℚ) = (9460730472580800 : ℚ)" }, { "id": "c47", "rung": 8, "claim": "A parsec, the ruler for the universe, is about 3.26 light-years", "form": "au * 648000 / pi / lightyear ~= 3.26", "how": "lean", "check": "defined", "proof": "Lean theorem Checked.fact_792b18acab (LeanProofs/Checked.lean) states exactly what the browser checker checks here, over exact fractions; it builds with no sorry and rests only on Lean's standard axioms. The browser checker re-ran it while this map was made: exact value about 3.26156377717; the answer said 3.26, which allows up to 0.005 either way.", "notProven": "The parsec and the light-year are both defined exactly; any distance measured in them is not proven here.", "source": "checked", "theorem": "Checked.fact_792b18acab", "answer": "au * 648000 / pi / lightyear ~= 3.26", "statement": "651/200 ≤ (149597870700:ℝ) * 648000 / Real.pi / 9460730472580800 ∧ (149597870700:ℝ) * 648000 / Real.pi / 9460730472580800 ≤ 653/200" }, { "id": "c48", "rung": 8, "claim": "Light takes about 499 seconds, a little over 8 minutes, to cross one astronomical unit", "form": "au / c ~= 499", "how": "lean", "check": "defined", "proof": "Lean theorem Checked.fact_11d8614ede (LeanProofs/Checked.lean) states exactly what the browser checker checks here, over exact fractions; it builds with no sorry and rests only on Lean's standard axioms. The browser checker re-ran it while this map was made: exact value 499.004783836; the answer said 499, which allows up to 0.5 either way.", "notProven": "Both numbers are exact definitions; the real Earth to Sun distance changes through the year.", "source": "checked", "theorem": "Checked.fact_11d8614ede", "answer": "au / c ~= 499", "statement": "((997 : ℚ) / 2) ≤ (149597870700 : ℚ) / (299792458 : ℚ) ∧ (149597870700 : ℚ) / (299792458 : ℚ) ≤ ((999 : ℚ) / 2)" } ] }