@ceccec/millennium-solutions 9.8.3 → 9.8.7

package/dist/data/discovered.json

@@ -149404,5 +149404,725 @@
     "key": "lean_qpu_the_mirror_coin_does_not_distribute_over_a_product",
     "name": "lean qpu.lean: the_mirror_coin_does_not_distribute_over_a_product — ¬ (List.range 24).all (fun p => (List.range 24).all (fun q => mirrorNat 4 (p * q) == 0 || mirrorNat 4 (p * q) == mirrorNat 4 p * mirrorNat 4 q)) — decided by the Lean kernel over its whole finite domain, axiom-free",
     "receipt": "438bc706-f838-8544-8fa7-9b80aa130576"
+  },
+  {
+    "key": "lean_qpucrypto_the_seal_exponent_is_an_rsa_permutation_of_the_residues_mod_ninety_one",
+    "name": "lean qpu_crypto.lean: the_seal_exponent_is_an_rsa_permutation_of_the_residues_mod_ninety_one — sealModulus = 91 ∧ sealExponent = 7 ∧ sealFold = 8 ∧ totient = 72 ∧ sealExponent * rsaInverse = 3 * totient + 1 ∧ (List.range sealModulus).all (fun r => rsa rsaInverse (rsa sealExponent r) == r) ∧ (List.range' 2 6).map permutes = [false, fa… — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "7b1cb7f0-6e09-8643-9e81-549e0433ebd8"
+  },
+  {
+    "key": "lean_qpucrypto_the_fold_mod_eight_is_where_the_seal_misses_one_tamper_in_eight",
+    "name": "lean qpu_crypto.lean: the_fold_mod_eight_is_where_the_seal_misses_one_tamper_in_eight — (List.range' 1 8).all (fun v => nibbleCount v == (if v ≤ 3 then 12 else 11)) ∧ nibbleCount 0 = 0 ∧ (List.range' 9 7).all (fun v => nibbleCount v == 0) ∧ (List.range' 1 8).foldl (fun acc v => acc + nibbleCount v) 0 = sealModulus ∧ (List.rang… — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "2882a7f0-b5be-82f5-b401-dbade1f9e213"
+  },
+  {
+    "key": "lean_qpucrypto_the_fixed_version_eight_and_the_decided_nibble_agree_on_eleven_residues_in_ninety_one",
+    "name": "lean qpu_crypto.lean: the_fixed_version_eight_and_the_decided_nibble_agree_on_eleven_residues_in_ninety_one — nibbleCount 8 = 11 ∧ 11 * 8 < sealModulus ∧ sealModulus < 12 * 8 ∧ (List.range sealModulus).all (fun r => 1 ≤ sealOf r && sealOf r ≤ 8) ∧ (List.range sealModulus).any (fun r => sealOf r == 8) ∧ (List.range sealModulus).all (fun r => sealOf … — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "66f5b5f0-fd03-8cf4-9403-93bca14fb093"
+  },
+  {
+    "key": "lean_qpucrypto_the_free_register_is_one_hundred_twenty_two_on_both_sides",
+    "name": "lean qpu_crypto.lean: the_free_register_is_one_hundred_twenty_two_on_both_sides — (List.range 9).all (fun w => (qpuRegister w == Capacity.free) == (w == Qpu.hexbit)) ∧ qpuRegister Qpu.hexbit = Capacity.free ∧ Capacity.free = 122 ∧ 32 * Qpu.hexbit = Capacity.container ∧ Qpu.hexbit + 2 = Capacity.reserved ∧ qpuRegister Qpu… — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "326edcf3-72dd-81ba-89cd-6356cb805f85"
+  },
+  {
+    "key": "lean_qpucrypto_one_coin_sits_sixty_seven_bits_below_the_iso_post_quantum_floor_under_grover",
+    "name": "lean qpu_crypto.lean: one_coin_sits_sixty_seven_bits_below_the_iso_post_quantum_floor_under_grover — groverExponent = 61 ∧ collisionExponent = 40 ∧ 3 * collisionExponent < Capacity.free ∧ Capacity.free < 3 * (collisionExponent + 1) ∧ 2 ^ collisionExponent < 2 ^ groverExponent ∧ 2 ^ groverExponent < 2 ^ isoFloor ∧ 2 ^ isoFloor < 2 ^ (2 * is… — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "ff9ca0d0-791c-8669-89cb-e1a227f850cd"
+  },
+  {
+    "key": "lean_qpucrypto_shor_on_ninety_one_splits_from_qpus_base_and_from_fifty_three_others",
+    "name": "lean qpu_crypto.lean: shor_on_ninety_one_splits_from_qpus_base_and_from_fifty_three_others — shorBase = 8 ∧ period shorBase sealModulus = 4 ∧ gcd (powMod shorBase 2 sealModulus - 1) sealModulus = Qpu.rays ∧ gcd (powMod shorBase 2 sealModulus + 1) sealModulus = Qpu.faces - 1 ∧ (List.range' 1 20).all (fun a => (List.range' 1 20).all … — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "961ea69a-548d-808b-b346-ed0564fc1779"
+  },
+  {
+    "key": "lean_qpucrypto_the_sigma_trapdoor_is_fermats_difference_of_squares",
+    "name": "lean qpu_crypto.lean: the_sigma_trapdoor_is_fermats_difference_of_squares — oddPrimes = [3, 5, 7, 11, 13, 17, 19, 23, 29] ∧ oddPrimes.all (fun p => oddPrimes.all (fun q => !(p < q) || witness p q * witness p q - p * q == ((q - p) / 2) * ((q - p) / 2))) ∧ oddPrimes.all (fun p => oddPrimes.all (fun q => !(p < q) || s… — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "c6b38fad-65f3-8e6f-a0f8-896921884d39"
+  },
+  {
+    "key": "lean_qpucrypto_a_wrong_witness_decodes_nothing_because_a_semiprime_has_one_split",
+    "name": "lean qpu_crypto.lean: a_wrong_witness_decodes_nothing_because_a_semiprime_has_one_split — small = [3, 5, 7, 11, 13, 17, 19] ∧ small.all (fun p => small.all (fun q => !(p < q) || (List.range' (ceilSqrt (p * q)) ((p * q + 1) / 2 - ceilSqrt (p * q))).all (fun x => decodes (p * q) x == (x == witness p q)))) — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "7cd9b9c8-5b7b-881f-a0dc-f2a535d48bb1"
+  },
+  {
+    "key": "lean_qpucrypto_an_impossible_integer_with_twin_primes_is_opened_blind_in_one_reflection",
+    "name": "lean qpu_crypto.lean: an_impossible_integer_with_twin_primes_is_opened_blind_in_one_reflection — blind 11 13 = 1 ∧ blind 5 7 = 1 ∧ blind 3 29 = 7 ∧ (oddPrimes.filter (fun p => isPrime (p + 2))) = [3, 5, 11, 17, 29] ∧ oddPrimes.all (fun p => !(isPrime (p + 2)) || blind p (p + 2) == 1) ∧ oddPrimes.all (fun p => oddPrimes.all (fun q => !(… — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "8d734da1-4537-8cf8-8522-080e983d634b"
+  },
+  {
+    "key": "lean_qpucrypto_the_thousand_bit_integer_has_a_thousand_bits_and_exactly_four_threes",
+    "name": "lean qpu_crypto.lean: the_thousand_bit_integer_has_a_thousand_bits_and_exactly_four_threes — 2 ^ 999 ≤ thousand ∧ thousand < 2 ^ 1000 ∧ (List.range' 1 6).all (fun k => (thousand % 3 ^ k == 0) == (k ≤ 4)) ∧ 999 = 27 * 37 ∧ (2 ^ 333 + 1) * (2 ^ 666 - 2 ^ 333 + 1) = thousand ∧ (2 ^ 111 + 1) * (2 ^ 222 - 2 ^ 111 + 1) = 2 ^ 333 + 1 ∧ (2… — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "a27fc1e7-abce-8861-887f-eadf9c491982"
+  },
+  {
+    "key": "lean_qpucrypto_this_deposits_factor_route_returns_a_partial_answer_that_multiplies_back",
+    "name": "lean qpu_crypto.lean: this_deposits_factor_route_returns_a_partial_answer_that_multiplies_back — found.foldl (· * ·) 1 * cofactor = thousand ∧ found.length = 14 ∧ (found.filter (· == 3)).length = 4 ∧ found.all (fun p => 1 < p && cofactor % p != 0) ∧ cofactor % 2 = 1 ∧ cofactor % 3 = 1 ∧ powModBin 2 (cofactor - 1) cofactor ≠ 1 ∧ powModB… — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "215f8bbc-e55e-8529-b6d2-e3089499c01b"
+  },
+  {
+    "key": "lean_qpucrypto_qpus_gl2_is_the_general_linear_group_over_two_elements_not_over_a_field_of_two_to_the_n",
+    "name": "lean qpu_crypto.lean: qpus_gl2_is_the_general_linear_group_over_two_elements_not_over_a_field_of_two_to_the_n — gl 2 = 6 ∧ gl 3 = 168 ∧ gl 4 = 20160 ∧ gl 5 = 9999360 ∧ gl 2 = 1 * 2 * 3 ∧ gl 3 = 7 * (7 * 7 - 1) / 2 ∧ (List.range' 1 6).all (fun nn => gl nn % (2 ^ nn - 1) == 0) ∧ (List.range' 2 5).all (fun nn => gl nn < 2 ^ (nn * nn)) — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "0bcfa091-9fbd-8222-ac32-05a80d9bb360"
+  },
+  {
+    "key": "lean_qpucrypto_a_prime_exponent_is_necessary_for_a_mersenne_prime_and_eleven_shows_it_is_not_sufficient",
+    "name": "lean qpu_crypto.lean: a_prime_exponent_is_necessary_for_a_mersenne_prime_and_eleven_shows_it_is_not_sufficient — (List.range 60).all (fun n => smallPrime n == isPrime n) ∧ 2 ^ 13 - 1 < 100 * 100 ∧ (List.range' 2 12).all (fun p => !(smallPrime (2 ^ p - 1)) || smallPrime p) ∧ [2, 3, 5, 7, 13].all (fun p => smallPrime p && smallPrime (2 ^ p - 1)) ∧ small… — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "77132148-88fe-8779-9c60-fa759fc83b07"
+  },
+  {
+    "key": "lean_qpucrypto_the_seal_modulus_is_the_thirteenth_triangular_number_and_the_gates_of_a_thirteen_qubit_qft",
+    "name": "lean qpu_crypto.lean: the_seal_modulus_is_the_thirteenth_triangular_number_and_the_gates_of_a_thirteen_qubit_qft — triangular 13 = sealModulus ∧ Qpu.faces * (Qpu.faces - 1) / 2 = sealModulus ∧ (List.range 40).all (fun q => (triangular q == sealModulus) == (q == 13)) ∧ (List.range 40).all (fun q => triangular q == Qpu.clayQftGates q) ∧ triangular (Qpu.fa… — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "a2d3e9ae-2b89-80b9-a3ea-af5c05dd2810"
+  },
+  {
+    "key": "lean_qpucrypto_qpus_grover_count_carries_pi_as_zu_chongzhis_three_hundred_fifty_five_over_one_hundred_thirteen",
+    "name": "lean qpu_crypto.lean: qpus_grover_count_carries_pi_as_zu_chongzhis_three_hundred_fifty_five_over_one_hundred_thirteen — milu = (355, 113) ∧ 3141592 * 113 < 355 * 1000000 ∧ 355 * 1000000 < 3141593 * 113 ∧ groverIters 355 113 2 = 3 ∧ groverIters 355 113 5 = 25 ∧ groverIters 355 113 6 = 50 ∧ groverIters 22 7 5 = 25 ∧ groverIters 3 1 5 = 24 ∧ (List.range 8).all … — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "c07d5f0c-6fa7-8fa2-961d-0ccbee5e1dcb"
+  },
+  {
+    "key": "lean_qpucrypto_the_eight_scales_reach_two_to_the_thirty_seven_and_the_thousand_bit_piece_is_one_more_for_no_reason",
+    "name": "lean qpu_crypto.lean: the_eight_scales_reach_two_to_the_thirty_seven_and_the_thousand_bit_piece_is_one_more_for_no_reason — (List.range' 1 8).map scaleCapacity = [64, 2048, 49152, 1048576, 20971520, 402653184, 7516192768, 137438953472] ∧ scaleCapacity 8 = 2 ^ 37 ∧ 16 ^ 8 = 2 ^ 32 ∧ 4 * 8 = Qpu.bits ∧ 2 ^ 37 + 1 = 3 * 1777 * 25781083 ∧ 999 / 27 = 37 ∧ 4 * 8 + 5 =… — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "42aaaec0-af4a-8fe9-8834-13cd59fb004a"
+  },
+  {
+    "key": "lean_qpugateway_the_variant_nibble_is_always_eight_through_eleven",
+    "name": "lean qpu_gateway.lean: the_variant_nibble_is_always_eight_through_eleven — (List.range 16).all (fun low => 8 ≤ variant low && variant low ≤ 11) ∧ (List.range 16).any (fun low => variant low == 8) ∧ (List.range 16).any (fun low => variant low == 11) ∧ (List.range 16).all (fun low => variant low != 7 && variant low … — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "f4d42ee8-2110-8d0d-a801-15e780f1d536"
+  },
+  {
+    "key": "lean_qpugateway_the_two_gateway_bits_are_always_the_pattern_two",
+    "name": "lean qpu_gateway.lean: the_two_gateway_bits_are_always_the_pattern_two — (List.range 16).all (fun low => gateway low == 2) ∧ (List.range 16).all (fun low => variant low / 4 == 2 && variant low % 4 == low % 4) — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "d44c8833-8a37-803e-a005-50649e75b9cc"
+  },
+  {
+    "key": "lean_qpugateway_reassembly_fixes_the_variant_to_eight_gateway_still_two",
+    "name": "lean qpu_gateway.lean: reassembly_fixes_the_variant_to_eight_gateway_still_two — fromPartsVariant = 8 ∧ fromPartsVariant / 4 = 2 ∧ fromPartsVariant % 4 = 0 ∧ gateway (fromPartsVariant % 4) = 2 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "e6db2c92-f5ef-81de-a43a-442e02123b32"
+  },
+  {
+    "key": "lean_qpugateway_the_ftl_gateway_check_is_a_tautology",
+    "name": "lean qpu_gateway.lean: the_ftl_gateway_check_is_a_tautology — ((List.range 16).filter (fun low => gateway low != 2)).length = 0 ∧ ((List.range 16).filter (fun low => gateway low == 2)).length = 16 ∧ ((List.range 16).filter (fun low => variant low == 8)).length = 4 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "c81e9dd1-c90d-85c0-b41d-ed0c8115c602"
+  },
+  {
+    "key": "lean_qpugateway_the_gateway_bits_take_one_value_so_carry_zero_entropy",
+    "name": "lean qpu_gateway.lean: the_gateway_bits_take_one_value_so_carry_zero_entropy — (List.range 16).any (fun low => gateway low == 2) ∧ (List.range 16).all (fun low => gateway low == 2) ∧ (List.range 4).all (fun v => (v == 2) || ((List.range 16).filter (fun low => gateway low == v)).length == 0) ∧ 1 = 2 ^ 0 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "546d55e9-6e3b-8db7-914b-b4229bc67880"
+  },
+  {
+    "key": "lean_qpugateway_a_free_two_bit_field_takes_four_values_the_gateway_takes_one",
+    "name": "lean qpu_gateway.lean: a_free_two_bit_field_takes_four_values_the_gateway_takes_one — [0, 1, 2, 3].all (fun v => (List.range 16).any (fun low => freeField low == v)) ∧ [0, 1, 2, 3].all (fun v => ((List.range 16).filter (fun low => freeField low == v)).length == 4) ∧ [0, 1, 3].all (fun v => (List.range 16).all (fun low => gat… — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "24c1171e-784f-83ca-8253-4f977ffce4c0"
+  },
+  {
+    "key": "lean_qpugateway_teleportation_sends_one_of_four_the_gateway_is_fixed_to_one",
+    "name": "lean qpu_gateway.lean: teleportation_sends_one_of_four_the_gateway_is_fixed_to_one — teleportMessages.length = 4 ∧ teleportMessages = [0, 1, 2, 3] ∧ teleportMessages.contains 2 = true ∧ (teleportMessages.filter (fun m => m == 2)).length = 1 ∧ (List.range 16).all (fun low => gateway low == 2) — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "4326302c-3322-8dd3-a6a4-45311867002b"
+  },
+  {
+    "key": "lean_qpugateway_the_ftl_premise_fails_the_named_carrier_carries_nothing",
+    "name": "lean qpu_gateway.lean: the_ftl_premise_fails_the_named_carrier_carries_nothing — ((List.range 16).map gateway).all (fun g => g == 2) ∧ (teleportMessages.filter (fun m => (List.range 16).all (fun low => gateway low == m))).length = 1 ∧ (teleportMessages.filter (fun m => (List.range 16).any (fun low => gateway low == m &&… — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "b9147af4-255c-84bd-b2d7-85171125d39b"
+  },
+  {
+    "key": "lean_width_the_register_at_each_width",
+    "name": "lean width.lean: the_register_at_each_width — widths.map reg = [122, 246, 494, 990] ∧ widths.all (fun w => reg w == 32 * w - w - 2) ∧ widths.all (fun w => reg w == 31 * w - 2) — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "09832000-1d91-8df1-b0c6-d5c1d7bba3cf"
+  },
+  {
+    "key": "lean_width_the_grover_exponent_at_each_width",
+    "name": "lean width.lean: the_grover_exponent_at_each_width — widths.map grover = [61, 123, 247, 495] ∧ widths.all (fun w => grover w == reg w / 2) — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "a35c6282-efa4-8801-a75b-3a969e0e5d1b"
+  },
+  {
+    "key": "lean_width_the_iso_floor_is_cleared_exactly_from_width_sixteen",
+    "name": "lean width.lean: the_iso_floor_is_cleared_exactly_from_width_sixteen — widths.all (fun w => (isoFloor ≤ grover w) == (16 ≤ w)) ∧ grover 4 < isoFloor ∧ grover 8 < isoFloor ∧ isoFloor ≤ grover 16 ∧ isoFloor ≤ grover 32 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "09aeba49-34f9-85ec-a4f1-3bba002abf7d"
+  },
+  {
+    "key": "lean_width_clearing_the_floor_is_two_hundred_fifty_six_free_bits",
+    "name": "lean width.lean: clearing_the_floor_is_two_hundred_fifty_six_free_bits — widths.all (fun w => (isoFloor ≤ grover w) == (256 ≤ reg w)) ∧ reg 8 < 256 ∧ 256 ≤ reg 16 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "07ab92f3-334b-807f-9dba-04fbdde7be4d"
+  },
+  {
+    "key": "lean_width_the_uuid_is_width_four_and_sits_sixty_seven_below",
+    "name": "lean width.lean: the_uuid_is_width_four_and_sits_sixty_seven_below — reg 4 = 122 ∧ grover 4 = 61 ∧ isoFloor - grover 4 = 67 ∧ 32 * 4 = 128 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "86e3cce5-7ea8-87d1-b7ee-bc32e3dd36a1"
+  },
+  {
+    "key": "lean_width_the_register_grows_strictly_with_the_width",
+    "name": "lean width.lean: the_register_grows_strictly_with_the_width — reg 4 < reg 8 ∧ reg 8 < reg 16 ∧ reg 16 < reg 32 ∧ grover 4 < grover 8 ∧ grover 8 < grover 16 ∧ grover 16 < grover 32 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "9aa19d70-0ee0-8cec-aee8-39fec7ee49d6"
+  },
+  {
+    "key": "lean_width_clearing_the_floor_needs_a_cost_exponent_of_at_least_256",
+    "name": "lean width.lean: clearing_the_floor_needs_a_cost_exponent_of_at_least_256 — 256 ≤ reg 16 ∧ reg 8 < 256 ∧ 2 ^ 128 < 2 ^ 256 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "3660343e-b344-8be2-b409-b9e320cdcd4d"
+  },
+  {
+    "key": "lean_width_the_cost_exponent_is_more_than_the_square_root_exponent_at_every_width",
+    "name": "lean width.lean: the_cost_exponent_is_more_than_the_square_root_exponent_at_every_width — widths.all (fun w => grover w < reg w) ∧ widths.all (fun w => reg w - grover w == (reg w + 1) / 2) ∧ (reg 4 - grover 4) < (reg 32 - grover 32) — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "1f8c76c6-acdf-8590-95eb-60bd60367edb"
+  },
+  {
+    "key": "lean_qec_the_surface_code_physical_count_is_two_d_squared_minus_two_d_plus_one",
+    "name": "lean qec.lean: the_surface_code_physical_count_is_two_d_squared_minus_two_d_plus_one — (List.range' 1 9).map surfacePhysical = [1, 5, 13, 25, 41, 61, 85, 113, 145] ∧ surfacePhysical 3 = 13 ∧ (List.range' 1 9).all (fun d => surfacePhysical d == 2 * d ^ 2 - 2 * d + 1) — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "2f5a9e47-88be-81ee-b176-22af11b0a9ce"
+  },
+  {
+    "key": "lean_qec_a_distance_d_code_corrects_the_floor_of_d_minus_one_over_two",
+    "name": "lean qec.lean: a_distance_d_code_corrects_the_floor_of_d_minus_one_over_two — (List.range' 1 9).map corrects = [0, 0, 1, 1, 2, 2, 3, 3, 4] ∧ corrects 5 = 2 ∧ (List.range' 1 9).all (fun d => 2 * corrects d + 1 ≤ d && d ≤ 2 * corrects d + 2) — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "850a2e71-e603-86ad-b0cf-72a15ef31470"
+  },
+  {
+    "key": "lean_qec_distance_one_corrects_nothing_and_distance_three_corrects_one",
+    "name": "lean qec.lean: distance_one_corrects_nothing_and_distance_three_corrects_one — corrects 1 = 0 ∧ corrects 3 = 1 ∧ surfacePhysical 1 = 1 ∧ surfacePhysical 3 = 13 ∧ surfacePhysical 1 < surfacePhysical 3 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "2a40933b-9a3d-8f90-886a-a774ae248313"
+  },
+  {
+    "key": "lean_qec_shors_nine_qubit_code_is_three_by_three_distance_three_correcting_one",
+    "name": "lean qec.lean: shors_nine_qubit_code_is_three_by_three_distance_three_correcting_one — 3 * 3 = 9 ∧ corrects 3 = 1 ∧ (3 - 1) / 2 = 1 ∧ 1 ≤ corrects 3 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "56934b0c-f9c6-8be2-bc54-079e3b9fcd99"
+  },
+  {
+    "key": "lean_qec_the_pauli_group_order_is_two_to_the_two_n_plus_two",
+    "name": "lean qec.lean: the_pauli_group_order_is_two_to_the_two_n_plus_two — (List.range' 1 4).map pauliOrder = [16, 64, 256, 1024] ∧ pauliOrder 1 = 16 ∧ (List.range' 1 4).all (fun nn => pauliOrder nn == 4 * 4 ^ nn) — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "8081d489-50d4-820c-93be-bd4ae0ead537"
+  },
+  {
+    "key": "lean_qec_the_surface_count_is_quadratic_not_linear_in_the_distance",
+    "name": "lean qec.lean: the_surface_count_is_quadratic_not_linear_in_the_distance — surfacePhysical 2 - surfacePhysical 1 = 4 ∧ surfacePhysical 3 - surfacePhysical 2 = 8 ∧ (surfacePhysical 2 - surfacePhysical 1) ≠ (surfacePhysical 3 - surfacePhysical 2) ∧ (List.range' 1 8).all (fun d => surfacePhysical (d + 1) - surfacePhy… — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "c1485e96-3455-880f-b19b-8ee56aee2506"
+  },
+  {
+    "key": "lean_qec_a_higher_distance_costs_more_qubits_and_corrects_no_fewer",
+    "name": "lean qec.lean: a_higher_distance_costs_more_qubits_and_corrects_no_fewer — (List.range' 1 8).all (fun d => surfacePhysical d < surfacePhysical (d + 1)) ∧ (List.range' 1 8).all (fun d => corrects d ≤ corrects (d + 1)) — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "5ea2b3b7-8b31-854e-887d-b9dcda7396e1"
+  },
+  {
+    "key": "lean_qec_the_counts_at_distance_nine_and_their_finite_bound",
+    "name": "lean qec.lean: the_counts_at_distance_nine_and_their_finite_bound — surfacePhysical 9 = 145 ∧ corrects 9 = 4 ∧ (List.range' 1 9).all (fun d => corrects d < 5 && surfacePhysical d < 200) ∧ (List.range' 1 9).all (fun d => 2 * corrects d ≤ d) — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "94df7814-6a9b-8175-91fc-29a84d7fda95"
+  },
+  {
+    "key": "lean_synthesis_the_single_qubit_clifford_group_has_order_twenty_four",
+    "name": "lean synthesis.lean: the_single_qubit_clifford_group_has_order_twenty_four — symp 1 = 6 ∧ clifford 1 = 24 ∧ 24 = 4 * 6 ∧ 6 = 1 * 2 * 3 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "d020524d-9854-8f40-96fd-2c2b0dd9f301"
+  },
+  {
+    "key": "lean_synthesis_the_symplectic_group_order_at_each_rank",
+    "name": "lean synthesis.lean: the_symplectic_group_order_at_each_rank — (List.range' 1 3).map symp = [6, 720, 1451520] ∧ (List.range' 1 3).all (fun nn => symp nn == 2 ^ (nn * nn) * sympProd nn) — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "8f6ec87e-58e7-8f6b-bd2a-8d7929502ea9"
+  },
+  {
+    "key": "lean_synthesis_the_two_qubit_clifford_group_has_order_eleven_thousand_five_hundred_twenty",
+    "name": "lean synthesis.lean: the_two_qubit_clifford_group_has_order_eleven_thousand_five_hundred_twenty — clifford 2 = 11520 ∧ clifford 2 = 16 * 720 ∧ clifford 1 < clifford 2 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "2251b51d-3eb6-80e8-94c8-935933a6808e"
+  },
+  {
+    "key": "lean_synthesis_fibonacci_anyon_fusion_is_the_fibonacci_number",
+    "name": "lean synthesis.lean: fibonacci_anyon_fusion_is_the_fibonacci_number — (List.range' 1 10).map fib = [1, 1, 2, 3, 5, 8, 13, 21, 34, 55] ∧ fib 5 = 5 ∧ fib 10 = 55 ∧ (List.range' 1 10).all (fun n => fib (n + 2) == fib (n + 1) + fib n) — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "d88a129e-299e-8253-8d39-331bafd2d227"
+  },
+  {
+    "key": "lean_synthesis_ising_anyon_fusion_is_two_to_the_m_minus_one_and_differs_from_fibonacci",
+    "name": "lean synthesis.lean: ising_anyon_fusion_is_two_to_the_m_minus_one_and_differs_from_fibonacci — (List.range' 1 5).map ising = [1, 2, 4, 8, 16] ∧ ising 3 = 4 ∧ fib 5 ≠ ising 5 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "d5d458e8-1805-8a13-aa51-0339ef3def8d"
+  },
+  {
+    "key": "lean_synthesis_the_fifteen_to_one_magic_code_is_fifteen_one_three",
+    "name": "lean synthesis.lean: the_fifteen_to_one_magic_code_is_fifteen_one_three — 2 ^ 4 - 1 = 15 ∧ (3 - 1) / 2 = 1 ∧ 35 = 28 + 7 ∧ 15 = 1 + 14 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "7886acdc-5b54-89b9-b414-9871622fbc3e"
+  },
+  {
+    "key": "lean_synthesis_qaoa_resource_counts_over_the_layers",
+    "name": "lean synthesis.lean: qaoa_resource_counts_over_the_layers — (List.range' 1 5).map qaoaParams = [2, 4, 6, 8, 10] ∧ qaoaZz 2 5 = 10 ∧ qaoaX 3 4 = 12 ∧ (List.range' 1 5).all (fun p => qaoaParams p == 2 * p) — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "618c7a94-a77f-85e2-88b2-d303de952704"
+  },
+  {
+    "key": "lean_synthesis_these_are_exact_orders_and_counts_decided_over_a_finite_domain",
+    "name": "lean synthesis.lean: these_are_exact_orders_and_counts_decided_over_a_finite_domain — (List.range' 1 3).all (fun nn => clifford nn == 2 ^ (2 * nn) * symp nn) ∧ (List.range' 1 10).all (fun n => 0 < fib (n + 1)) ∧ clifford 2 = 11520 ∧ symp 3 = 1451520 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "4d407f23-69c3-87d2-ba25-2c1a0750966a"
+  },
+  {
+    "key": "lean_resources_the_chimera_annealer_qubit_count_is_eight_m_squared",
+    "name": "lean resources.lean: the_chimera_annealer_qubit_count_is_eight_m_squared — (List.range' 1 8).map chimera = [8, 32, 72, 128, 200, 288, 392, 512] ∧ chimera 16 = 2048 ∧ (List.range' 1 16).all (fun m => chimera m == 8 * m ^ 2) — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "6341e55b-e8e9-89d4-8d9c-86df76c9218a"
+  },
+  {
+    "key": "lean_resources_the_pegasus_annealer_count_is_twenty_four_m_times_m_minus_one",
+    "name": "lean resources.lean: the_pegasus_annealer_count_is_twenty_four_m_times_m_minus_one — pegasus 16 = 5760 ∧ pegasus 1 = 0 ∧ pegasus 2 = 48 ∧ (List.range' 1 16).all (fun m => pegasus m == 24 * m * (m - 1)) — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "9f843d7d-8ff1-8811-bc89-2f35d471c70e"
+  },
+  {
+    "key": "lean_resources_the_qft_gate_count_is_the_triangular_number",
+    "name": "lean resources.lean: the_qft_gate_count_is_the_triangular_number — (List.range' 1 8).map qftGates = [1, 3, 6, 10, 15, 21, 28, 36] ∧ qftGates 3 = 6 ∧ qftGates 4 = 10 ∧ (List.range' 1 8).all (fun q => 2 * qftGates q == q * (q + 1)) — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "b1349979-7935-87f6-8691-97ff7771672c"
+  },
+  {
+    "key": "lean_resources_the_qft_swaps_depth_and_states",
+    "name": "lean resources.lean: the_qft_swaps_depth_and_states — qftSwaps 4 = 2 ∧ qftDepth 4 = 7 ∧ qftStates 4 = 16 ∧ (List.range' 1 8).all (fun q => qftStates q == 2 ^ q) ∧ (List.range' 1 8).all (fun q => qftDepth q == 2 * q - 1) — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "ce12b693-0614-887e-930b-030b907227d1"
+  },
+  {
+    "key": "lean_resources_archimedes_twenty_two_over_seven_bounds_pi_above_and_the_floor_is_three",
+    "name": "lean resources.lean: archimedes_twenty_two_over_seven_bounds_pi_above_and_the_floor_is_three — 14 + 8 = 22 ∧ 22 * 100000 > 314159 * 7 ∧ 3 * 7 < 22 ∧ 22 < 4 * 7 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "ec31e290-c514-88be-9a70-184fc62d860c"
+  },
+  {
+    "key": "lean_resources_zu_chongzhis_three_fifty_five_over_one_thirteen_brackets_pi_to_six_places",
+    "name": "lean resources.lean: zu_chongzhis_three_fifty_five_over_one_thirteen_brackets_pi_to_six_places — 28 * (14 - 1) - 3 * 3 = 355 ∧ 28 * 4 + 1 = 113 ∧ 3141592 * 113 < 355 * 1000000 ∧ 355 * 1000000 < 3141593 * 113 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "1e43cac7-ff77-848f-992f-230420530cf6"
+  },
+  {
+    "key": "lean_resources_the_turn_is_three_hundred_sixty_degrees_and_the_half_turn_one_eighty",
+    "name": "lean resources.lean: the_turn_is_three_hundred_sixty_degrees_and_the_half_turn_one_eighty — (14 - 2) * (28 + 2) = 360 ∧ (14 - 2) * (14 + 1) = 180 ∧ 360 = 2 * 180 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "097b1d2b-8b94-8f99-b029-8f53b00cb1b3"
+  },
+  {
+    "key": "lean_resources_these_are_exact_counts_and_rational_convergents_not_pi_itself",
+    "name": "lean resources.lean: these_are_exact_counts_and_rational_convergents_not_pi_itself — chimera 16 = 2048 ∧ pegasus 16 = 5760 ∧ qftGates 10 = 55 ∧ 22 * 7 = 154 ∧ 355 * 113 = 40115 ∧ (List.range' 1 8).all (fun q => qftGates q < qftStates q) — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "1ebfd2f4-000b-8f6a-abd4-eb7c3ad7f076"
+  },
+  {
+    "key": "lean_combinatorics_the_factorial_counts_the_orderings",
+    "name": "lean combinatorics.lean: the_factorial_counts_the_orderings — (List.range 8).map factorial = [1, 1, 2, 6, 24, 120, 720, 5040] ∧ factorial 3 = 6 ∧ (List.range 7).all (fun n => factorial (n + 1) == (n + 1) * factorial n) — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "9ecd10ea-f751-8a27-b3dd-6c8249b14dfd"
+  },
+  {
+    "key": "lean_combinatorics_the_binomial_coefficients_follow_pascals_rule",
+    "name": "lean combinatorics.lean: the_binomial_coefficients_follow_pascals_rule — (List.range 6).map (fun k => choose 5 k) = [1, 5, 10, 10, 5, 1] ∧ choose 5 2 = 10 ∧ (List.range 6).all (fun n => (List.range 6).all (fun k => choose (n + 1) (k + 1) == choose n (k + 1) + choose n k)) — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "ea786f87-603d-85b2-828f-3f30db7bc51e"
+  },
+  {
+    "key": "lean_combinatorics_the_binomial_is_symmetric",
+    "name": "lean combinatorics.lean: the_binomial_is_symmetric — choose 5 2 = choose 5 3 ∧ choose 6 2 = choose 6 4 ∧ (List.range 7).all (fun k => choose 6 k == choose 6 (6 - k)) — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "7a026991-51ed-8536-ad98-9ed8cbca9c36"
+  },
+  {
+    "key": "lean_combinatorics_the_triangular_numbers_are_the_handshake_count",
+    "name": "lean combinatorics.lean: the_triangular_numbers_are_the_handshake_count — (List.range 9).map triangular = [0, 1, 3, 6, 10, 15, 21, 28, 36] ∧ triangular 4 = 10 ∧ (List.range 8).all (fun n => 2 * triangular (n + 1) == (n + 1) * (n + 2)) — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "feb4da67-debf-88ec-ae86-3254b90eee3d"
+  },
+  {
+    "key": "lean_combinatorics_ramsey_two_n_is_n_and_two_people_make_one_pair",
+    "name": "lean combinatorics.lean: ramsey_two_n_is_n_and_two_people_make_one_pair — (List.range' 2 6).map ramsey22 = [2, 3, 4, 5, 6, 7] ∧ ramsey22 2 = 2 ∧ triangular 1 = 1 ∧ (List.range 10).all (fun n => ramsey22 n == n) — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "0bb8f2b9-74ab-83d1-8458-eabf585cc85b"
+  },
+  {
+    "key": "lean_combinatorics_the_factorial_outgrows_the_power_of_two",
+    "name": "lean combinatorics.lean: the_factorial_outgrows_the_power_of_two — (List.range' 1 7).all (fun n => 2 ^ (n - 1) ≤ factorial n) ∧ factorial 4 = 24 ∧ 2 ^ 3 = 8 ∧ 8 < 24 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "74f6f6a2-86da-8873-9dcc-ff54debdbe3c"
+  },
+  {
+    "key": "lean_combinatorics_the_binomial_row_sums_to_two_to_the_n",
+    "name": "lean combinatorics.lean: the_binomial_row_sums_to_two_to_the_n — ((List.range 6).map (fun k => choose 5 k)).foldl (· + ·) 0 = 32 ∧ 32 = 2 ^ 5 ∧ (List.range 7).all (fun n => ((List.range (n + 1)).map (fun k => choose n k)).foldl (· + ·) 0 == 2 ^ n) — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "07959ae0-e8d2-8729-8521-167556c9a8e2"
+  },
+  {
+    "key": "lean_combinatorics_these_are_exact_counts_decided_not_a_physical_machine",
+    "name": "lean combinatorics.lean: these_are_exact_counts_decided_not_a_physical_machine — factorial 7 = 5040 ∧ choose 5 2 = 10 ∧ triangular 8 = 36 ∧ ramsey22 9 = 9 ∧ (List.range 7).all (fun n => choose n 0 == 1 && choose n n == 1) — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "03e80abe-991e-8c25-a3bc-1fbf431001e7"
+  },
+  {
+    "key": "lean_thousandbit_the_thousand_bit_case_is_one_hundred_twenty_five_octaves",
+    "name": "lean thousandbit.lean: the_thousand_bit_case_is_one_hundred_twenty_five_octaves — 1000 = 125 * 8 ∧ 1000 % 8 = 0 ∧ 999 % 8 ≠ 0 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "d9b1d5f8-5e70-861c-9190-b842d849a1f0"
+  },
+  {
+    "key": "lean_thousandbit_the_binary_units_tile_the_thousand_exactly",
+    "name": "lean thousandbit.lean: the_binary_units_tile_the_thousand_exactly — 1000 = 500 * 2 ∧ 1000 = 250 * 4 ∧ 1000 = 125 * 8 ∧ 1000 % 2 = 0 ∧ 1000 % 4 = 0 ∧ 1000 % 8 = 0 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "8e10d5d0-4fd5-8270-bd9a-fbe92e54dafd"
+  },
+  {
+    "key": "lean_thousandbit_the_thousand_is_the_cube_octave_times_pentagram_cubed",
+    "name": "lean thousandbit.lean: the_thousand_is_the_cube_octave_times_pentagram_cubed — 10 ^ 3 = 1000 ∧ 2 ^ 3 * 5 ^ 3 = 1000 ∧ 2 ^ 3 = 8 ∧ 5 ^ 3 = 125 ∧ 125 * 8 = 1000 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "6c535031-7658-894f-9d12-f18103af15a2"
+  },
+  {
+    "key": "lean_thousandbit_the_thousand_carries_residue_one_mod_nine",
+    "name": "lean thousandbit.lean: the_thousand_carries_residue_one_mod_nine — 1000 % 9 = 1 ∧ 1000 = 9 * 111 + 1 ∧ 999 % 9 = 0 ∧ 1008 % 9 = 0 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "bb60beff-feee-8f49-af32-8fdf48844a97"
+  },
+  {
+    "key": "lean_thousandbit_the_thousand_bit_case_overflows_the_width_thirty_two_ceiling",
+    "name": "lean thousandbit.lean: the_thousand_bit_case_overflows_the_width_thirty_two_ceiling — 32 * 32 - 32 - 2 = 990 ∧ 990 < 1000 ∧ 32 * 33 - 33 - 2 = 1021 ∧ 1000 ≤ 1021 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "fb28d220-8bc2-878c-93bb-87754b1f7cd6"
+  },
+  {
+    "key": "lean_thousandbit_the_minimal_register_for_the_thousand_is_width_thirty_three",
+    "name": "lean thousandbit.lean: the_minimal_register_for_the_thousand_is_width_thirty_three — 1000 - 990 = 10 ∧ 1021 - 1000 = 21 ∧ 990 < 1000 ∧ 1000 ≤ 1021 ∧ (32 * 33 - 33 - 2) / 2 = 510 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "e00c13fe-c68a-8e49-8004-4b456917e12a"
+  },
+  {
+    "key": "lean_thousandbit_the_thousand_fills_between_ninety_seven_and_ninety_eight_percent_of_its_register",
+    "name": "lean thousandbit.lean: the_thousand_fills_between_ninety_seven_and_ninety_eight_percent_of_its_register — 97 * 1021 < 1000 * 100 ∧ 1000 * 100 < 98 * 1021 ∧ 97 * 1021 = 99037 ∧ 98 * 1021 = 100058 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "2283c459-1a73-8ab3-8878-c69f8884fc75"
+  },
+  {
+    "key": "lean_thousandbit_the_thousand_bit_structure_is_decided_not_a_quantum_machine",
+    "name": "lean thousandbit.lean: the_thousand_bit_structure_is_decided_not_a_quantum_machine — 10 ^ 3 = 1000 ∧ 1000 % 8 = 0 ∧ 1000 % 9 = 1 ∧ 990 < 1000 ∧ 1000 ≤ 1021 ∧ 2 ^ 3 * 5 ^ 3 = 1000 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "54965178-f8b9-8feb-8dfc-9a5dfb6e0ae3"
+  },
+  {
+    "key": "lean_quantumhardware_every_deterministic_local_strategy_gives_chsh_plus_or_minus_two",
+    "name": "lean quantum_hardware.lean: every_deterministic_local_strategy_gives_chsh_plus_or_minus_two — [1, -1].all (fun a0 : Int => [1, -1].all (fun a1 : Int => [1, -1].all (fun b0 : Int => [1, -1].all (fun b1 : Int => let s := a0 * b0 + a0 * b1 + a1 * b0 - a1 * b1; s == 2 || s == -2)))) = true — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "6f5bb0ee-7cb2-80ab-b027-a20966141ba6"
+  },
+  {
+    "key": "lean_quantumhardware_the_classical_strategy_at_s_two_is_not_above_classical",
+    "name": "lean quantum_hardware.lean: the_classical_strategy_at_s_two_is_not_above_classical — aboveClassical 1000 1000 1000 1000 1000 1000 1000 1000 = false — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "e4044e10-ff4b-802d-a960-d3a967589da5"
+  },
+  {
+    "key": "lean_quantumhardware_one_count_above_s_two_is_above_classical",
+    "name": "lean quantum_hardware.lean: one_count_above_s_two_is_above_classical — aboveClassical 1000 1000 1000 1000 1000 1000 998 1000 = true — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "98565f45-367c-8dc5-8a1a-0959a2e133b2"
+  },
+  {
+    "key": "lean_quantumhardware_one_count_below_s_two_is_not_above_classical",
+    "name": "lean quantum_hardware.lean: one_count_below_s_two_is_not_above_classical — aboveClassical 998 1000 1000 1000 1000 1000 1000 1000 = false — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "8f9b9743-75f7-8de1-94cd-1cde4e981c38"
+  },
+  {
+    "key": "lean_quantumhardware_uniform_noise_is_not_above_classical",
+    "name": "lean quantum_hardware.lean: uniform_noise_is_not_above_classical — aboveClassical 0 1000 0 1000 0 1000 0 1000 = false — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "94dd7798-c93b-8e54-be0c-cc704a01fe64"
+  },
+  {
+    "key": "lean_quantumhardware_ideal_counts_at_ten_thousand_shots_are_above_classical",
+    "name": "lean quantum_hardware.lean: ideal_counts_at_ten_thousand_shots_are_above_classical — 4268 + 732 + 732 + 4268 = 10000 ∧ 4268 + 4268 - 732 - 732 = 7072 ∧ aboveClassical 7072 10000 7072 10000 7072 10000 (-7072) 10000 = true — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "a6013c39-32bb-83ac-994f-1d80b864b501"
+  },
+  {
+    "key": "lean_quantumhardware_register_bit_zero_is_alice_and_bit_one_is_bob",
+    "name": "lean quantum_hardware.lean: register_bit_zero_is_alice_and_bit_one_is_bob — (List.range 4).map (fun v => (v % 2, v / 2 % 2)) = [(0, 0), (1, 0), (0, 1), (1, 1)] — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "f245f123-5e0c-890d-949c-445c1e42ffe2"
+  },
+  {
+    "key": "lean_quantumhardware_the_one_count_control_is_four_hundred_ninety_nine_agreements_short_of_five_hundred",
+    "name": "lean quantum_hardware.lean: the_one_count_control_is_four_hundred_ninety_nine_agreements_short_of_five_hundred — (499 + 500 - 1 - 0 : Int) = 998 ∧ (499 + 1 + 0 + 500 : Int) = 1000 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "923841a0-97d3-834b-b376-265a7eb49c43"
+  },
+  {
+    "key": "lean_quantumcircuits_the_sent_preparation_is_a_bell_pair",
+    "name": "lean quantum_circuits.lean: the_sent_preparation_is_a_bell_pair — (run bell).2.1 = (0, 0, 0, 0) ∧ (run bell).2.2.1 = (0, 0, 0, 0) ∧ (run bell).1 = (run bell).2.2.2 ∧ zadd (norm (run bell).1) (norm (run bell).2.2.2) = (64, 0, 0, 0) — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "da2dc76d-7b59-86e4-b216-0e0e66a191b7"
+  },
+  {
+    "key": "lean_quantumcircuits_alice_zero_bob_plus_quarter_correlates_root_two_over_two",
+    "name": "lean quantum_circuits.lean: alice_zero_bob_plus_quarter_correlates_root_two_over_two — total (chsh 4 5) = (16384, 0, 0, 0) ∧ corr (chsh 4 5) = root2 8192 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "3c70945e-a70b-8e54-98ab-4205a929fcd5"
+  },
+  {
+    "key": "lean_quantumcircuits_alice_zero_bob_minus_quarter_correlates_root_two_over_two",
+    "name": "lean quantum_circuits.lean: alice_zero_bob_minus_quarter_correlates_root_two_over_two — total (chsh 4 3) = (16384, 0, 0, 0) ∧ corr (chsh 4 3) = root2 8192 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "84c1cfd1-8be9-82e7-bf66-7aa8e84ca7d2"
+  },
+  {
+    "key": "lean_quantumcircuits_alice_half_bob_plus_quarter_correlates_root_two_over_two",
+    "name": "lean quantum_circuits.lean: alice_half_bob_plus_quarter_correlates_root_two_over_two — total (chsh 6 5) = (16384, 0, 0, 0) ∧ corr (chsh 6 5) = root2 8192 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "7f5e5a33-69c9-8f16-87ca-eeee366977a3"
+  },
+  {
+    "key": "lean_quantumcircuits_alice_half_bob_minus_quarter_anticorrelates_root_two_over_two",
+    "name": "lean quantum_circuits.lean: alice_half_bob_minus_quarter_anticorrelates_root_two_over_two — total (chsh 6 3) = (16384, 0, 0, 0) ∧ corr (chsh 6 3) = root2 (-8192) — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "352c5e78-715b-8102-a100-4efcd3b62440"
+  },
+  {
+    "key": "lean_quantumcircuits_the_sent_circuits_reach_s_two_root_two",
+    "name": "lean quantum_circuits.lean: the_sent_circuits_reach_s_two_root_two — zadd (zadd (corr (chsh 4 5)) (corr (chsh 4 3))) (zadd (corr (chsh 6 5)) (zneg (corr (chsh 6 3)))) = root2 32768 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "4688e005-e75d-8aea-a014-e7f725c28c96"
+  },
+  {
+    "key": "lean_quantumcircuits_bob_at_angle_zero_correlates_fully_not_root_two_over_two",
+    "name": "lean quantum_circuits.lean: bob_at_angle_zero_correlates_fully_not_root_two_over_two — corr (chsh 4 4) = (16384, 0, 0, 0) ∧ corr (chsh 4 4) ≠ root2 8192 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "1e25ee29-0fb6-8ad8-901c-fdc646d661f7"
+  },
+  {
+    "key": "lean_quantumcircuits_without_the_entangler_the_correlation_vanishes",
+    "name": "lean quantum_circuits.lean: without_the_entangler_the_correlation_vanishes — corr ((bell.filter (fun g => match g with | .cz => false | _ => true)) ++ [.rz 0 4, .sx 0, .rz 0 4, .sx 0, .rz 1 4, .sx 1, .rz 1 5, .sx 1]) = (0, 0, 0, 0) — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "5947cb2c-eefc-8844-b0bf-b5e428b02aae"
+  },
+  {
+    "key": "lean_quantummodels_one_way_measurement_applies_h_rz_for_every_angle_and_both_outcomes",
+    "name": "lean quantum_models.lean: one_way_measurement_applies_h_rz_for_every_angle_and_both_outcomes — (List.range 8).all (fun k => (List.range 2).all (fun m => oneWay true k m == gateOut k m)) = true — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "769136b1-2e36-8a13-b4a6-0580adfa92ae"
+  },
+  {
+    "key": "lean_quantummodels_one_way_without_the_cluster_bond_does_not_apply_the_gate",
+    "name": "lean quantum_models.lean: one_way_without_the_cluster_bond_does_not_apply_the_gate — oneWay false 0 0 ≠ gateOut 0 0 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "c6462474-585b-8741-9141-a4e423e9f642"
+  },
+  {
+    "key": "lean_quantummodels_ising_anyon_braids_satisfy_the_braid_relation",
+    "name": "lean quantum_models.lean: ising_anyon_braids_satisfy_the_braid_relation — prop (mmul sigma1 (mmul sigma2 sigma1)) (mmul sigma2 (mmul sigma1 sigma2)) = true — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "e13c5091-6b94-86d4-ac4f-f80342b379e1"
+  },
+  {
+    "key": "lean_quantummodels_ising_anyon_braids_generate_exactly_the_twenty_four_clifford_classes",
+    "name": "lean quantum_models.lean: ising_anyon_braids_generate_exactly_the_twenty_four_clifford_classes — (braidGroup 8).length = 24 ∧ (grow (braidGroup 8)).length = 24 ∧ prop sigma1 ident = false — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "953f132c-e01e-8320-987c-86e32fa27965"
+  },
+  {
+    "key": "lean_quantummodels_every_balanced_beam_splitter_gives_a_full_depth_hong_ou_mandel_dip",
+    "name": "lean quantum_models.lean: every_balanced_beam_splitter_gives_a_full_depth_hong_ou_mandel_dip — (List.range 8).all (fun a => (List.range 8).all (fun b => unitary2 (splitter a b) && permOf (splitter a b) == zero)) = true ∧ perm = zero ∧ zadd (zadd (norm (zmul u00 u10)) (norm (zmul u00 u10))) (zadd (norm (zmul u01 u11)) (norm (zmul u01 … — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "f6d41c2d-7720-8a74-a782-b24909bf5dac"
+  },
+  {
+    "key": "lean_quantummodels_distinguishable_photons_coincide_half_the_time",
+    "name": "lean quantum_models.lean: distinguishable_photons_coincide_half_the_time — zadd (norm (zmul u00 u11)) (norm (zmul u01 u10)) = (2, 0, 0, 0) ∧ norm perm = zero — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "6f6a9450-5c5a-8af3-8c68-1785dfc1b6b0"
+  },
+  {
+    "key": "lean_quantummodels_the_adiabatic_gap_is_smallest_exactly_at_the_midpoint_at_every_resolution",
+    "name": "lean quantum_models.lean: the_adiabatic_gap_is_smallest_exactly_at_the_midpoint_at_every_resolution — (List.range 101).all (fun n => (List.range (n + 1)).all (fun t => let n' : Int := n; let t' : Int := t 2 * ((n' - t') ^ 2 + t' ^ 2) == n' ^ 2 + (2 * t' - n') ^ 2 && (2 * ((n' - t') ^ 2 + t' ^ 2) == n' ^ 2) == (2 * t' == n'))) = true — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "f6e9816c-c2b7-8ba2-b9b2-e63ba4655471"
+  },
+  {
+    "key": "lean_quantummodels_the_frustrated_triangle_has_a_six_fold_ground_state_at_minus_one",
+    "name": "lean quantum_models.lean: the_frustrated_triangle_has_a_six_fold_ground_state_at_minus_one — triangle.all (fun e => e ≥ -1) = true ∧ (triangle.filter (fun e => e == -1)).length = 6 ∧ (triangle.filter (fun e => e == 3)).length = 2 ∧ triangle.length = 8 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "5ad73761-1088-8e58-b0a6-60d48636a945"
+  },
+  {
+    "key": "lean_quantumtextbooks_tsirelsons_eight_is_the_square_of_the_circuits_s",
+    "name": "lean quantum_textbooks.lean: tsirelsons_eight_is_the_square_of_the_circuits_s — zmul (root2 32768) (root2 32768) = (8 * 16384 * 16384, 0, 0, 0) ∧ zadd (zadd (corr (chsh 4 5)) (corr (chsh 4 3))) (zadd (corr (chsh 6 5)) (zneg (corr (chsh 6 3)))) = root2 32768 ∧ 2 * 2 < 8 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "c4a4eaea-f8b3-8813-a45e-ec4887c48e5f"
+  },
+  {
+    "key": "lean_quantumtextbooks_the_group_generated_by_h_and_s_has_exactly_twenty_four_classes",
+    "name": "lean quantum_textbooks.lean: the_group_generated_by_h_and_s_has_exactly_twenty_four_classes — (generated [hs, sigma1] 8).length = 24 ∧ (closeUnder [hs, sigma1] (generated [hs, sigma1] 8)).length = 24 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "a3100a06-cbc5-8c18-a930-806f58db84e6"
+  },
+  {
+    "key": "lean_quantumtextbooks_t_has_order_exactly_eight_and_does_not_commute_with_h",
+    "name": "lean quantum_textbooks.lean: t_has_order_exactly_eight_and_does_not_commute_with_h — mpow tgate 8 = ident ∧ (List.range' 1 7).all (fun k => prop (mpow tgate k) ident == false) = true ∧ prop (mmul hs tgate) (mmul tgate hs) = false — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "85a515d0-90c7-8f4e-a1d0-8b51481536fb"
+  },
+  {
+    "key": "lean_quantumtextbooks_simons_measured_strings_for_period_eleven_are_exactly_two_of_four",
+    "name": "lean quantum_textbooks.lean: simons_measured_strings_for_period_eleven_are_exactly_two_of_four — (List.range 4).filter (fun y => dot y 3 == 0) = [0, 3] — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "dc623d89-3587-8611-8ee6-fda99a4c9a7a"
+  },
+  {
+    "key": "lean_quantumtextbooks_one_query_recovers_every_three_bit_hidden_string",
+    "name": "lean quantum_textbooks.lean: one_query_recovers_every_three_bit_hidden_string — (List.range 8).all (fun s => (List.range 8).all (fun y => ((List.range 8).foldl (fun acc x => acc + sign (dot s x) * sign (dot y x)) 0) == (if s == y then 8 else 0))) = true — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "9b6e62c2-ae50-8d26-afdf-4d26fbae0717"
+  },
+  {
+    "key": "lean_quantumtextbooks_one_query_separates_every_balanced_from_every_constant_function",
+    "name": "lean quantum_textbooks.lean: one_query_separates_every_balanced_from_every_constant_function — (List.range 256).all (fun m => let ones := (List.range 8).foldl (fun a x => a + m / 2 ^ x % 2) 0 let amp : Int := (List.range 8).foldl (fun a x => a + sign (m / 2 ^ x % 2)) 0 (amp == 0) == (ones == 4) && ((ones == 0 || ones == 8) == (amp ==… — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "78f72585-25b5-804d-935d-ba04f3d73ea1"
+  },
+  {
+    "key": "lean_quantumtextbooks_one_grover_iteration_finds_every_marked_item_of_four_with_certainty",
+    "name": "lean quantum_textbooks.lean: one_grover_iteration_finds_every_marked_item_of_four_with_certainty — (List.range 4).all (fun m => (List.range 4).map (fun i => (1 : Int) - (if i == m then -1 else 1)) == (List.range 4).map (fun i => if i == m then 2 else 0)) = true — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "a1ec3176-e55d-87ea-854e-2d568a244645"
+  },
+  {
+    "key": "lean_quantumtextbooks_linearity_forbids_perfect_cloning_and_the_optimal_copy_has_fidelity_five_sixths",
+    "name": "lean quantum_textbooks.lean: linearity_forbids_perfect_cloning_and_the_optimal_copy_has_fidelity_five_sixths — ((1 : Int) * 1 - 0 * 1 ≠ 0) ∧ 4 + 1 + 1 = 6 ∧ 4 + 1 = 5 ∧ 5 < 6 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "f9710402-2c58-8a3d-8904-49a009e6b6e5"
+  },
+  {
+    "key": "lean_quantumoctave128_particle_zero_of_the_128_qubit_octave",
+    "name": "lean quantum_octave_128.lean: particle_zero_of_the_128_qubit_octave — particleReal 0 = true ∧ particleSum 0 = 3525990486864069858 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "63a59442-75de-86a6-b91d-00f196f6ebd0"
+  },
+  {
+    "key": "lean_quantumoctave128_particle_one_of_the_128_qubit_octave",
+    "name": "lean quantum_octave_128.lean: particle_one_of_the_128_qubit_octave — particleReal 1 = true ∧ particleSum 1 = 337654250015596702913742461840 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "7927486f-2fdb-8fd8-a419-7102cd1ae3e7"
+  },
+  {
+    "key": "lean_quantumoctave128_particle_two_of_the_128_qubit_octave",
+    "name": "lean quantum_octave_128.lean: particle_two_of_the_128_qubit_octave — particleReal 2 = true ∧ particleSum 2 = 411324807959075400680218172572805400 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "ed4e972b-cdbe-8fad-ae1b-803a55fea38d"
+  },
+  {
+    "key": "lean_quantumoctave128_particle_three_of_the_128_qubit_octave",
+    "name": "lean quantum_octave_128.lean: particle_three_of_the_128_qubit_octave — particleReal 3 = true ∧ particleSum 3 = 145778712272927823445748804366324216880 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "f57cb061-1a23-8fb9-9882-89efbdea8390"
+  },
+  {
+    "key": "lean_quantumoctave128_particle_four_of_the_128_qubit_octave",
+    "name": "lean quantum_octave_128.lean: particle_four_of_the_128_qubit_octave — particleReal 4 = true ∧ particleSum 4 = 192812936693211996284838821959307547180 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "8ee6ddd3-f251-8ecc-9486-ee3fb1267386"
+  },
+  {
+    "key": "lean_quantumoctave128_particle_five_of_the_128_qubit_octave",
+    "name": "lean quantum_octave_128.lean: particle_five_of_the_128_qubit_octave — particleReal 5 = true ∧ particleSum 5 = 1279389515917225289300042767401030000 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "0f062ce6-fd9e-8ded-891a-fddc0a730af2"
+  },
+  {
+    "key": "lean_quantumoctave128_particle_six_of_the_128_qubit_octave",
+    "name": "lean quantum_octave_128.lean: particle_six_of_the_128_qubit_octave — particleReal 6 = true ∧ particleSum 6 = 3293268092833471993876167655640 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "4d71e764-6ffa-87ee-9dbf-0ea0758e1757"
+  },
+  {
+    "key": "lean_quantumoctave128_particle_seven_of_the_128_qubit_octave",
+    "name": "lean quantum_octave_128.lean: particle_seven_of_the_128_qubit_octave — particleReal 7 = true ∧ particleSum 7 = 190212032889388424658 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "bb6d83a4-c2b5-88bf-9663-1f24f93096af"
+  },
+  {
+    "key": "lean_quantumoctaves_every_classical_answer_is_root_two_times_an_odd_eighth_of_the_circle",
+    "name": "lean quantum_octaves.lean: every_classical_answer_is_root_two_times_an_odd_eighth_of_the_circle — zmul (root2 1) (wpow 1) = (1, 0, 1, 0) ∧ zmul (root2 1) (wpow 3) = (-1, 0, 1, 0) ∧ zmul (root2 1) (wpow 5) = (-1, 0, -1, 0) ∧ zmul (root2 1) (wpow 7) = (1, 0, -1, 0) — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "203c8974-68af-8406-b4aa-aba3e57a2baa"
+  },
+  {
+    "key": "lean_quantumoctaves_octave_two_qubits_has_no_mermin_lead",
+    "name": "lean quantum_octaves.lean: octave_two_qubits_has_no_mermin_lead — expectationsReal 2 = true ∧ twiceQuantum 2 = 2 * 2 ^ 1 ∧ reach 2 = [0, 2, 4, 6] ∧ 2 ^ (2 / 2) = 2 ^ (2 - 1) — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "5b2e033a-87bd-8131-b20b-dce1a3ca0e6b"
+  },
+  {
+    "key": "lean_quantumoctaves_octave_four_qubits_quantum_eight_against_classical_four",
+    "name": "lean quantum_octaves.lean: octave_four_qubits_quantum_eight_against_classical_four — expectationsReal 4 = true ∧ twiceQuantum 4 = 2 * 2 ^ 3 ∧ reach 4 = [0, 2, 4, 6] ∧ 2 ^ (4 / 2) < 2 ^ (4 - 1) — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "2fe170c8-c71b-8898-98ce-d76bd04684a4"
+  },
+  {
+    "key": "lean_quantumoctaves_octave_eight_qubits_quantum_128_against_classical_16",
+    "name": "lean quantum_octaves.lean: octave_eight_qubits_quantum_128_against_classical_16 — expectationsReal 8 = true ∧ twiceQuantum 8 = 2 * 2 ^ 7 ∧ reach 8 = [0, 2, 4, 6] ∧ 2 ^ (8 / 2) * 2 ^ 3 = 2 ^ (8 - 1) — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "0c3f6a6b-bd95-8715-a347-c80a1ed4bbe9"
+  },
+  {
+    "key": "lean_quantumoctaves_octave_sixteen_qubits_the_lead_is_two_to_the_seventh",
+    "name": "lean quantum_octaves.lean: octave_sixteen_qubits_the_lead_is_two_to_the_seventh — expectationsReal 16 = true ∧ twiceQuantum 16 = 2 * 2 ^ 15 ∧ reach 16 = [0, 2, 4, 6] ∧ 2 ^ (16 / 2) * 2 ^ 7 = 2 ^ (16 - 1) — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "6f72b857-08ff-83ce-96f5-dd6341809aa0"
+  },
+  {
+    "key": "lean_quantumoctaves_octave_thirty_two_qubits_the_lead_is_two_to_the_fifteenth",
+    "name": "lean quantum_octaves.lean: octave_thirty_two_qubits_the_lead_is_two_to_the_fifteenth — expectationsReal 32 = true ∧ twiceQuantum 32 = 2 * 2 ^ 31 ∧ reach 32 = [0, 2, 4, 6] ∧ 2 ^ (32 / 2) * 2 ^ 15 = 2 ^ (32 - 1) — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "6db05559-a0a8-8ae6-b55d-bf7314d22dc8"
+  },
+  {
+    "key": "lean_quantumoctaves_octave_sixty_four_qubits_the_lead_is_two_to_the_thirty_first",
+    "name": "lean quantum_octaves.lean: octave_sixty_four_qubits_the_lead_is_two_to_the_thirty_first — expectationsReal 64 = true ∧ twiceQuantum 64 = 2 * 2 ^ 63 ∧ reach 64 = [0, 2, 4, 6] ∧ 2 ^ (64 / 2) * 2 ^ 31 = 2 ^ (64 - 1) — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "27f1eaf6-a361-8299-9976-21a2f9724f41"
+  },
+  {
+    "key": "lean_quantumoctave128_octave_one_twenty_eight_qubits_the_uuid_width_leads_by_two_to_the_sixty_third",
+    "name": "lean quantum_octave_128.lean: octave_one_twenty_eight_qubits_the_uuid_width_leads_by_two_to_the_sixty_third — covered = true ∧ particleSum 0 + particleSum 1 + particleSum 2 + particleSum 3 + particleSum 4 + particleSum 5 + particleSum 6 + particleSum 7 = 2 * 2 ^ 127 ∧ reach 128 = [0, 2, 4, 6] ∧ 2 ^ (128 / 2) * 2 ^ 63 = 2 ^ (128 - 1) — proved by the Lean kernel for every value (by\n  refine), standard axioms only — checked by lean.ts",
+    "receipt": "6dbff2e6-728f-84e2-a251-b33073eef0d2"
+  },
+  {
+    "key": "lean_quantumoctave124_particle_zero_of_the_124_qubit_sum",
+    "name": "lean quantum_octave_124.lean: particle_zero_of_the_124_qubit_sum — particleReal 0 = true ∧ particleSum 0 = 2207731770981467816 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "d026f5a5-a073-883b-bc5f-1c649460e2a4"
+  },
+  {
+    "key": "lean_quantumoctave124_particle_one_of_the_124_qubit_sum",
+    "name": "lean quantum_octave_124.lean: particle_one_of_the_124_qubit_sum — particleReal 1 = true ∧ particleSum 1 = 115248474140745261396647375336 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "25840d76-485f-872e-a0b8-b188137ca6a5"
+  },
+  {
+    "key": "lean_quantumoctave124_particle_two_of_the_124_qubit_sum",
+    "name": "lean quantum_octave_124.lean: particle_two_of_the_124_qubit_sum — particleReal 2 = true ∧ particleSum 2 = 70087461568327544489265647434286536 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "9e9ac5e9-6627-86ea-851c-04d529aa2e53"
+  },
+  {
+    "key": "lean_quantumoctave124_particle_three_of_the_124_qubit_sum",
+    "name": "lean quantum_octave_124.lean: particle_three_of_the_124_qubit_sum — particleReal 3 = true ∧ particleSum 3 = 12084539867274399785808019555594845576 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "0b1f0ae3-3a80-8282-8cc4-79661565a4b6"
+  },
+  {
+    "key": "lean_quantumoctave124_particle_four_of_the_124_qubit_sum",
+    "name": "lean quantum_octave_124.lean: particle_four_of_the_124_qubit_sum — particleReal 4 = true ∧ particleSum 4 = 9091273897550055524364275883821099256 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "487b4f06-e20d-8293-8b34-d7b2d4513067"
+  },
+  {
+    "key": "lean_quantumoctave124_particle_five_of_the_124_qubit_sum",
+    "name": "lean quantum_octave_124.lean: particle_five_of_the_124_qubit_sum — particleReal 5 = true ∧ particleSum 5 = 21746580107261245372128218160439736 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "184d5582-d5c8-88a6-b588-b961e7f4cda0"
+  },
+  {
+    "key": "lean_quantumoctave124_particle_six_of_the_124_qubit_sum",
+    "name": "lean quantum_octave_124.lean: particle_six_of_the_124_qubit_sum — particleReal 6 = true ∧ particleSum 6 = 10810135723442052600830956696 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "feb7a8bc-b826-869f-9b81-45d149cb6a20"
+  },
+  {
+    "key": "lean_quantumoctave124_particle_seven_of_the_124_qubit_sum",
+    "name": "lean quantum_octave_124.lean: particle_seven_of_the_124_qubit_sum — particleReal 7 = true ∧ particleSum 7 = 32177891015042264 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "d09a7b84-1faf-8d96-afc8-64fbabb03421"
+  },
+  {
+    "key": "lean_quantumuuidcluster_at_odd_widths_the_classical_phase_stands_on_odd_eighths_and_the_bound_is_two_to_the_half_of_n_minus_one",
+    "name": "lean quantum_uuid_cluster.lean: at_odd_widths_the_classical_phase_stands_on_odd_eighths_and_the_bound_is_two_to_the_half_of_n_minus_one — [3, 5, 7, 9].all (fun n => expectationsReal n && twiceQuantum n == 2 * 2 ^ (n - 1) && reach n == [1, 3, 5, 7]) = true — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "9fcb4a5e-b397-8719-b2ce-b7c7f6e1b962"
+  },
+  {
+    "key": "lean_quantumuuidcluster_every_generator_of_the_124_qubit_cluster_is_z_x_z_on_its_neighbours",
+    "name": "lean quantum_uuid_cluster.lean: every_generator_of_the_124_qubit_cluster_is_z_x_z_on_its_neighbours — (List.range 124).all (fun j => gen 124 j == want 124 j) = true — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "6d9b30fa-2137-8ed5-a887-3d768c6bf10a"
+  },
+  {
+    "key": "lean_quantumuuidcluster_generators_zero_to_sixty_one_have_exactly_the_z_x_z_bit_pattern",
+    "name": "lean quantum_uuid_cluster.lean: generators_zero_to_sixty_one_have_exactly_the_z_x_z_bit_pattern — (List.range 62).all patterned = true — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "bb21eca5-87b2-8028-8df9-2ef30f02749e"
+  },
+  {
+    "key": "lean_quantumuuidcluster_generators_sixty_two_to_one_twenty_three_have_exactly_the_z_x_z_bit_pattern",
+    "name": "lean quantum_uuid_cluster.lean: generators_sixty_two_to_one_twenty_three_have_exactly_the_z_x_z_bit_pattern — (List.range' 62 62).all patterned = true — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "0829f1db-9667-8ec4-8352-4699427e3883"
+  },
+  {
+    "key": "lean_quantumuuidcluster_generators_zero_to_sixty_one_commute_with_all_124",
+    "name": "lean quantum_uuid_cluster.lean: generators_zero_to_sixty_one_commute_with_all_124 — (List.range 62).all (fun i => (List.range 124).all (fun j => commutes 124 i j)) = true — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "4f31f688-92b1-8948-84b8-f64910ae0cab"
+  },
+  {
+    "key": "lean_quantumuuidcluster_generators_sixty_two_to_one_twenty_three_commute_with_all_124",
+    "name": "lean quantum_uuid_cluster.lean: generators_sixty_two_to_one_twenty_three_commute_with_all_124 — (List.range' 62 62).all (fun i => (List.range 124).all (fun j => commutes 124 i j)) = true — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "dccffaa9-8b13-86d7-8d1a-985335b703a7"
+  },
+  {
+    "key": "lean_quantumuuidcluster_without_the_chain_or_with_a_ring_the_linear_cluster_form_fails",
+    "name": "lean quantum_uuid_cluster.lean: without_the_chain_or_with_a_ring_the_linear_cluster_form_fails — (List.range 124).all (fun j => (2 ^ j, 0, false) != want 124 j) = true ∧ cz 0 123 (gen 124 0) != want 124 0 ∧ cz 0 123 (gen 124 123) != want 124 123 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "8db4de29-4ec5-8fd4-bf71-f47ef2afc6b9"
+  },
+  {
+    "key": "lean_quantumuuidcluster_the_124_qubit_ghz_state_leads_every_classical_assignment_by_two_to_the_sixty_first",
+    "name": "lean quantum_uuid_cluster.lean: the_124_qubit_ghz_state_leads_every_classical_assignment_by_two_to_the_sixty_first — (2 ^ 4 = 16 ∧ 128 - 4 = 124 ∧ 128 - 4 - 2 = 122) ∧ particleSum 0 + particleSum 1 + particleSum 2 + particleSum 3 + particleSum 4 + particleSum 5 + particleSum 6 + particleSum 7 = 2 * 2 ^ 123 ∧ reach 124 = [0, 2, 4, 6] ∧ 2 ^ (124 / 2) * 2 ^ … — proved by the Lean kernel for every value (by\n  refine), standard axioms only — checked by lean.ts",
+    "receipt": "e037d2bb-d19b-8a9a-8b66-85a14d8b7e87"
+  },
+  {
+    "key": "lean_qpufold_the_transcribed_fold_step_reproduces_qpus_output",
+    "name": "lean qpu_fold.lean: the_transcribed_fold_step_reproduces_qpus_output — xor16 8997 97 = 9028 ∧ xor16 255 255 = 0 ∧ xor16 1234 0 = 1234 ∧ t0 8997 97 % mask = 60556 ∧ t1 8997 33826 97 % mask = 34305 ∧ t2 8997 33826 40164 97 % mask = 56396 ∧ newH3 8997 33826 40164 52210 97 = 44899 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "33f70f24-dfa3-8e81-948b-b9798994bb70"
+  },
+  {
+    "key": "lean_qpufold_the_fold_state_is_four_sixteen_bit_limbs_so_sixty_four_bits",
+    "name": "lean qpu_fold.lean: the_fold_state_is_four_sixteen_bit_limbs_so_sixty_four_bits — mask = 2 ^ 16 ∧ mask * mask * mask * mask = 2 ^ 64 ∧ 4 * 16 = 64 ∧ 64 / 4 = 16 ∧ (t0 8997 97 % mask) + (t1 8997 33826 97 % mask) * 2 ^ 16 + (t2 8997 33826 40164 97 % mask) * 2 ^ 32 + (newH3 8997 33826 40164 52210 97) * 2 ^ 48 < 2 ^ 64 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "42f70eaa-eab5-86ce-b1de-51b260260713"
+  },
+  {
+    "key": "lean_qpufold_the_coin_depends_only_on_the_state_so_distinct_texts_share_it",
+    "name": "lean qpu_fold.lean: the_coin_depends_only_on_the_state_so_distinct_texts_share_it — (List.range 40).all (fun t => coin t == coin (stateOf t)) ∧ coin 3 = coin (3 + 2 ^ W) ∧ (3 : Nat) ≠ 3 + 2 ^ W ∧ (List.range 40).all (fun a => (List.range 40).all (fun b => !(stateOf a == stateOf b) || coin a == coin b)) — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "f9b415f5-3cdc-8c3d-ad4e-e499972bdd9e"
+  },
+  {
+    "key": "lean_qpufold_a_narrow_fold_reaches_few_of_the_layouts_addresses",
+    "name": "lean qpu_fold.lean: a_narrow_fold_reaches_few_of_the_layouts_addresses — ((List.range (2 ^ Pbits)).filter (fun v => (List.range (2 ^ W)).any (fun s => coinOf s == v))).length = 2 ^ W ∧ (List.range (2 ^ Pbits)).length = 2 ^ Pbits ∧ 2 ^ Pbits - 2 ^ W = 240 ∧ 2 ^ W < 2 ^ Pbits — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "ba7a41f8-9112-84ab-9bd1-fa02ba52c14a"
+  },
+  {
+    "key": "lean_qpufold_two_independent_fields_reach_every_address_so_the_fold_is_the_cap",
+    "name": "lean qpu_fold.lean: two_independent_fields_reach_every_address_so_the_fold_is_the_cap — ((List.range (2 ^ Pbits)).filter (fun v => (List.range (2 ^ W)).any (fun a => (List.range (2 ^ W)).any (fun b => pairFill a b == v)))).length = 2 ^ Pbits ∧ 2 * W = Pbits — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "45a6b14e-7b38-8086-8d2a-2d14830b6a4f"
+  },
+  {
+    "key": "lean_qpufold_more_texts_than_states_force_a_coin_collision",
+    "name": "lean qpu_fold.lean: more_texts_than_states_force_a_coin_collision — (List.range (2 ^ W + 1)).any (fun i => (List.range (2 ^ W + 1)).any (fun j => i < j && stateOf i == stateOf j)) ∧ (List.range (2 ^ W)).all (fun i => (List.range (2 ^ W)).all (fun j => !(i < j) || stateOf i != stateOf j)) ∧ (List.range (2 ^ … — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "0627b471-b8c0-84d6-80fa-78f4ad41640e"
+  },
+  {
+    "key": "lean_qpufold_the_real_fold_is_sixty_four_bits_against_the_hundred_twenty_two_bit_layout",
+    "name": "lean qpu_fold.lean: the_real_fold_is_sixty_four_bits_against_the_hundred_twenty_two_bit_layout — 2 ^ 64 < 2 ^ 122 ∧ 2 ^ 64 * 2 ^ 58 = 2 ^ 122 ∧ 122 - 64 = 58 ∧ 2 ^ 122 - 2 ^ 64 > 0 ∧ mask * mask * mask * mask = 2 ^ 64 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "dd520b70-7d08-8b22-8936-0f97a326f4f5"
+  },
+  {
+    "key": "lean_qpufold_the_search_floor_is_the_fold_width_not_the_layout_width",
+    "name": "lean qpu_fold.lean: the_search_floor_is_the_fold_width_not_the_layout_width — 32 * 2 = 64 ∧ 61 * 2 = 122 ∧ 2 ^ 32 * 2 ^ 32 = 2 ^ 64 ∧ 2 ^ 32 < 2 ^ 61 ∧ 2 ^ 61 < 2 ^ 122 ∧ 2 ^ 64 < 2 ^ 122 — decided by the Lean kernel over its whole finite domain, axiom-free",
+    "receipt": "af6a8c7d-9084-8b32-bfd0-a1af4659aab3"
   }
 ]