diff --git a/certificates/joint-dual-kappa.json b/certificates/joint-dual-kappa.json index b7f7b89bc2..240efb3da1 100644 --- a/certificates/joint-dual-kappa.json +++ b/certificates/joint-dual-kappa.json @@ -837,12 +837,12 @@ "scripts/experiments/binary_frame_profiles.cpp": "8e2e391d3ee57cbb1372c68e4aa031e1b861321536eabd642ada54e12e678669", "scripts/experiments/binary_frame_replay.py": "1a572dbb33faba6695b3293768a7e61392d11cb4c2d5f708eedcd2cb95d0aff9", "scripts/experiments/joint_dual_compiler.py": "853d3fc4a740c5b74c23b3a6af5d4dc9b41fb38e9b55678539a7e0ee71947c13", - "scripts/experiments/joint_dual_compose.py": "741900aa6f69c0e3458700f3b534334269004ad80c50405ecfeda18e6d3f2800", + "scripts/experiments/joint_dual_compose.py": "3554e957570e2d3f65c5bd7c945338c9e2fc5f3e79efa2b436a4dfc61899c394", "scripts/experiments/joint_dual_reclaim_compiler.py": "9984aaccf880e4840402322d76678bfddb33ce7e494af78430a43429f51b85fd", - "scripts/experiments/pin_joint_dual_sources.py": "4d31cc0e38b7902709ca5f8f714cba109760d2592346dd7f8dc0b900a2d9fe00", + "scripts/experiments/pin_joint_dual_sources.py": "5d41535a73ad62fae7acb5365c5b7f40d7c99e52b6bc4266e44572018080acc5", "scripts/experiments/verify_joint_dual.py": "7a31bba1e9c0ded32ae285df2ca9bc91ef20c330f6789fdba361876f3c7a1985" }, - "source_manifest_sha256": "4f3c15b82a2d97335d4fe95fb8bcb96bd2a921087da289d9da16c68213a17f17", + "source_manifest_sha256": "e60f1f78c9729700ef9606a6576163de0b553792e5e8f24591dce5f51597158c", "sources": [ { "files": { diff --git a/certificates/joint-dual-validation.json b/certificates/joint-dual-validation.json index 194861d3c3..a5ee9f485a 100644 --- a/certificates/joint-dual-validation.json +++ b/certificates/joint-dual-validation.json @@ -226,7 +226,7 @@ } }, "bit_saving": "2382370177/50000000000000", - "certificate_sha256": "9801147b1502cf1e43d5fa39aa37f5291f03b48c30c4dd4f272e0877894a1c24", + "certificate_sha256": "a1329d6c5e78cef5c7381d5e5d79c0a8842db7e569892af3b7e763b6c46d6f96", "kappa": "4764513337/100000000000000", "margins": 7, "producer_words_regenerated_and_matched": true, diff --git a/docs/paired-cube.md b/docs/paired-cube.md index 38dc3d30e0..f10c339b2d 100644 --- a/docs/paired-cube.md +++ b/docs/paired-cube.md @@ -64,12 +64,14 @@ sources are included without a PDF. ## Shared source bindings -The final `Makefile`, `README.md` and `NOTICE` changes also update the inherited -joint-dual manifest. Explicitly refresh its hashes, regenerate joint arithmetic -and update the validation receipt's certificate digest. Its mathematical -fields and previous complete replay payload must remain equal when their -producer/verifier inputs are unchanged. The complete affected replay command, -when needed, is `make verify-joint`. +The inherited joint-dual manifest no longer binds `Makefile`, `README.md` or +`NOTICE`, so editing them does not touch it. Earlier round notes describe the +time when it did. If a bound producer, certificate or finite input changes, +explicitly refresh its hashes, regenerate joint arithmetic and update the +validation receipt's certificate digest. Its mathematical fields and previous +complete replay payload must remain equal when their producer/verifier inputs +are unchanged. The complete affected replay command, when needed, is +`make verify-joint`. Stage the final artifacts before the deterministic certificate regeneration and require `git diff --exit-code` to remain clean. CI checks the committed diff --git a/research/joint-dual/SOURCE.json b/research/joint-dual/SOURCE.json index e3a8386b17..e055d5d63d 100644 --- a/research/joint-dual/SOURCE.json +++ b/research/joint-dual/SOURCE.json @@ -3,9 +3,6 @@ "base_pr57_commit": "cd350f76c9bc01489ec83568bded532cb69be938", "base_pr58_commit": "bc2f7ed4c20dc18898305ab17165c0c995cbb804", "files": { - "Makefile": "768131bd4ce18433f6abccdc9812a38c92e11220e3a1019c6d95334b42f529d1", - "NOTICE": "b49022cb4104d90b182e4c335f670faf45529025b15db77bf0291835083c28bd", - "README.md": "d104c31d5b7e0d3a8d011a0e3517ab615e5b499b3dc05684f7ad3cadcd28bdae", "certificates/joint-dual-compiler.json": "516c4d85158553dabd0a98216a064b2a7397957a9d5dd0df1d6e5aec53a4e805", "certificates/joint-dual-profiles-23.json": "159fa8fee175fc1d24f63e72d3c2f1dc9f4fcd78b938c5e7d2f735fd0fd37209", "certificates/joint-dual-profiles-25.json": "8d190ce42d097e828c5756918c52f2963df576cf4c6600b0fc7f2b7fdb6ad223", @@ -49,9 +46,9 @@ "scripts/experiments/binary_frame_profiles.cpp": "8e2e391d3ee57cbb1372c68e4aa031e1b861321536eabd642ada54e12e678669", "scripts/experiments/binary_frame_replay.py": "1a572dbb33faba6695b3293768a7e61392d11cb4c2d5f708eedcd2cb95d0aff9", "scripts/experiments/joint_dual_compiler.py": "853d3fc4a740c5b74c23b3a6af5d4dc9b41fb38e9b55678539a7e0ee71947c13", - "scripts/experiments/joint_dual_compose.py": "741900aa6f69c0e3458700f3b534334269004ad80c50405ecfeda18e6d3f2800", + "scripts/experiments/joint_dual_compose.py": "3554e957570e2d3f65c5bd7c945338c9e2fc5f3e79efa2b436a4dfc61899c394", "scripts/experiments/joint_dual_reclaim_compiler.py": "9984aaccf880e4840402322d76678bfddb33ce7e494af78430a43429f51b85fd", - "scripts/experiments/pin_joint_dual_sources.py": "4d31cc0e38b7902709ca5f8f714cba109760d2592346dd7f8dc0b900a2d9fe00", + "scripts/experiments/pin_joint_dual_sources.py": "5d41535a73ad62fae7acb5365c5b7f40d7c99e52b6bc4266e44572018080acc5", "scripts/experiments/verify_joint_dual.py": "7a31bba1e9c0ded32ae285df2ca9bc91ef20c330f6789fdba361876f3c7a1985", "tests/test_joint_reclaim.py": "c4e2817bf6e699f462aa3c589ee45e24ab0dcad6bcdb6152ca2a1e16ac7bffeb" }, diff --git a/research/lean-count-receipt-amortization/ACCEPTED_CHECKS.json b/research/lean-count-receipt-amortization/ACCEPTED_CHECKS.json new file mode 100644 index 0000000000..5fe188e76a --- /dev/null +++ b/research/lean-count-receipt-amortization/ACCEPTED_CHECKS.json @@ -0,0 +1,802 @@ +{ + "kind": "Twelve-source historical research acceptance; exact public resumed reproduction separately completed", + "modules": [ + { + "module": "RippleCounterListData", + "source_sha256": "6ad007faa04e8f22895489011f48c6574dca4a31809f3456fbcf5bea4a5bb302", + "receipt_sha256": "4003fb6f6df4f36a4cc485b4c4ee795979f2d820ebf217e148bf4a826cfa5888", + "log_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "status": "PASS", + "started_utc": "2026-10-11T23:58:25.541299+00:00", + "finished_utc": "2026-10-11T23:58:27.306615+00:00", + "compile_seconds": 1.7653041230005329, + "queue_seconds": 0.00518836400078726, + "peak_vm_bytes": 1592274944, + "object_sha256": "462675831d027a5c02f492a65881e9d0a681d6be9032ea5ae06cf6406251b9a0" + }, + { + "module": "CounterArithmeticPure", + "source_sha256": "1ad26524cc5932842e8f233aa3b8b4f9c0ecb12a4ab06478c6c6f0c42827144b", + "receipt_sha256": "ef883813b0884c6f9825a2ca3bc68d0f343655014cd87297974c9702e9b191d1", + "log_sha256": "dda3fbe314a2f36a2e2fab87bf929c88a4cd469102c51a7e8e0f0c65bc175be0", + "status": "PASS", + "started_utc": "2026-10-12T00:13:47.848794+00:00", + "finished_utc": "2026-10-12T00:13:51.644544+00:00", + "compile_seconds": 3.7957488579995697, + "queue_seconds": 0.0012811779997718986, + "process_observations": { + "samples": 38, + "peak_vm_bytes": 1768648704, + "peak_rss_bytes": 1053003776, + "peak_threads": 4 + }, + "peak_vm_bytes": 1768648704, + "object_sha256": "3d3ef80267e98928090af6bb49c4a01790f93541b11c8c953c4f382119281b9d", + "current": true, + "epoch": "20261011" + }, + { + "module": "IntegerConvolution", + "source_sha256": "0bc86f2fa8e68f39df77be603d2a9634bc008745093286903105378ab45938ea", + "receipt_sha256": "9f4041c0a3fec637e8b47686837ec516d133df60b5482ec83d5aa774cf8adc62", + "log_sha256": "c1aea8c6ec85d16aa991288c1dbd640d2047900b669fb59a79e5d084d150f0c5", + "compile_seconds": 1.7111359120001453, + "queue_seconds": 0.00039078200006770203, + "peak_vm_bytes": 2265174016, + "status": "PASS", + "started_utc": "2026-10-11T20:17:31.900570+00:00", + "finished_utc": "2026-10-11T20:17:33.611709+00:00", + "object_sha256": "72299b15d1bee37af56e1c5d10018d45784213c43461021afc4c213d1863af36", + "matches_historical_object": true, + "current": true, + "epoch": "20261011" + }, + { + "module": "FixedTapeMachine", + "source_sha256": "92dadedc9f6e23d12633549b53ca8f917360e4fedac0b64a58d18feea741a5ed", + "receipt_sha256": "ea1bdd28da97ea51a45eb11bbcbee1dbcf1b835d9c7efc1796e7cbe81f784b55", + "log_sha256": "36dc8dbc05e17722f16160959d84aea237a472b8a2435c0fd7dc140e3f704559", + "compile_seconds": 1.66718382199997, + "queue_seconds": 0.00032932299995991343, + "peak_vm_bytes": 2063888384, + "status": "PASS", + "started_utc": "2026-10-11T20:17:34.574845+00:00", + "finished_utc": "2026-10-11T20:17:36.242033+00:00", + "object_sha256": "88fa2e0c9e43f696f53762a345092d19fa3501d7b1de2381dfb335b232b53ff1", + "matches_historical_object": true, + "current": true, + "epoch": "20261011" + }, + { + "module": "CarryTape", + "source_sha256": "20d13d9d2da74452e45c0a175b643556615ba14187bf8fb0e4393e44842c17a5", + "receipt_sha256": "c98c833a97cf4f96c38f54ea75e4c9309a6ff17baec4cee7f814627b88fe5041", + "log_sha256": "a269b42e17b5fd794216654bafc3ee3cc58c39fbbf5c36fa525eb42bfc739b67", + "compile_seconds": 2.51581714200006, + "queue_seconds": 0.00039194500004668953, + "peak_vm_bytes": 2735390720, + "status": "PASS", + "started_utc": "2026-10-11T20:21:09.928592+00:00", + "finished_utc": "2026-10-11T20:21:12.444412+00:00", + "object_sha256": "5ecb25ccf73c61eb5b4be13a69c73d9b7183201a71344e333761af7ea7915c74", + "current": true, + "epoch": "20261011" + }, + { + "module": "CarryTapePass", + "source_sha256": "680b5d16736880ac6a02f27e9503e1cc01479bb2b35bb7546d9108dcb4b4ef2b", + "receipt_sha256": "c2ddc97083ec113da2537650250a961be1e1fb4c76f5c6b53f7fcd137a37ddc9", + "log_sha256": "bf3a993154b0837224b4a4f76d6f48fc6508422904a4371309c777ba6936ddb6", + "compile_seconds": 2.506893128999991, + "queue_seconds": 0.0002887979999286472, + "peak_vm_bytes": 2735984640, + "status": "PASS", + "started_utc": "2026-10-11T20:21:13.415458+00:00", + "finished_utc": "2026-10-11T20:21:15.922354+00:00", + "object_sha256": "183f0edf242a2f6ecb9d9a07d62bc977d9fa04b3a32bad75a6c71344583c1147", + "current": true, + "epoch": "20261011" + }, + { + "module": "BinaryCarryIncrement", + "source_sha256": "b0f639159e2169c75e6d7a13663adee5107648a32b7ff9203f92792e31012dce", + "receipt_sha256": "dc6bc90c6a70cf077442fb309c012e1d6e6256137074cc1e6cd3e7a1b4a3cea9", + "log_sha256": "d249a6aaa4e3eec29d84596b492eac68b52d6c14c115df389f20f5b313d1f0ae", + "status": "PASS", + "started_utc": "2026-10-11T20:25:26.593822+00:00", + "finished_utc": "2026-10-11T20:25:28.676028+00:00", + "compile_seconds": 2.082204667000042, + "queue_seconds": 0.0004521139999269508, + "peak_vm_bytes": 2065498112, + "object_sha256": "07895c550c6298ae2143cca61c53399131f4b5a6a77b71f154c7ec6baa46ddc8", + "current": true, + "epoch": "20261011" + }, + { + "module": "BinaryCountDispatcher", + "source_sha256": "ec24af9483d59ce3248802378218d4b478490aa2458e136880f36e7f49356e93", + "receipt_sha256": "c701b66a9f5885ce456e95fc6af33d93d81e32c157ca11a69fa2049ab4840113", + "log_sha256": "514eb1cbe0db0c7bef18f845a35310c63653d757bb691d1cd0bc44c076c1a90f", + "status": "PASS", + "started_utc": "2026-10-11T20:37:41.048046+00:00", + "finished_utc": "2026-10-11T20:37:44.703455+00:00", + "compile_seconds": 3.6554057119997196, + "queue_seconds": 0.0005584489999819198, + "peak_vm_bytes": 2603089920, + "object_sha256": "6685bcc5f2657f829149fa21e0140e063750680997c072cbe2c661e5190fa97e", + "current": true, + "epoch": "20261011" + }, + { + "module": "BinaryCountDispatcherMarkedInput", + "source_sha256": "b7f0cecb69194b8d851037e8321e245dc383c62e3e2475c9d4508d29390191cc", + "receipt_sha256": "9e38c13f586fcc7e0768ab8c808bbe1a6b0dabf46563d71892e54e84bfa72fc4", + "log_sha256": "3067d6a5e9cbfe3ff1a19435b2e7392f68480ec46b5eefae9f998f49943a0dd8", + "status": "PASS", + "started_utc": "2026-10-11T20:59:19.447635+00:00", + "finished_utc": "2026-10-11T20:59:21.522936+00:00", + "compile_seconds": 2.075297555999896, + "queue_seconds": 0.000424994999775663, + "peak_vm_bytes": 2066251776, + "object_sha256": "bd14ae558577205f11c534c7ee5264ec2f8c6f321c92b5b08521b221470f9346", + "current": true, + "epoch": "20261011" + }, + { + "module": "BinaryCounterZeroAllocation", + "source_sha256": "5cf3fdfcd6c6a6cefa89b9a83dc678b6f40d9a608c318334ae92a66d25ea7477", + "receipt_sha256": "9c8cac2f332d82810bc502a9ef755625a17b2787c356ca27aba8bed3c1a8e1c4", + "log_sha256": "90de35142ca4dca8c3f4cd678abd99c728ab2ceb197abc0e5b14d2e566d3005c", + "status": "PASS", + "started_utc": "2026-10-11T23:08:09.331171+00:00", + "finished_utc": "2026-10-11T23:08:12.925864+00:00", + "compile_seconds": 3.5946979740001552, + "queue_seconds": 0.0007666310011700261, + "peak_vm_bytes": 3075186688, + "object_sha256": "48910f8b0674b728aaff6eba2463df006822795b24402747f3512c24636e1d72", + "current": true, + "epoch": "20261011" + }, + { + "module": "BinaryAutomaticWidthCount", + "source_sha256": "5dcf4ec74f08d9662738db413d144e16f4b555e56f29e0846ad5c88726420154", + "receipt_sha256": "54fd30866e2fe01f959a08125127679bc2a8d026d2bdee55345d52f1f0d583c3", + "log_sha256": "185599ae81bb180e4452e3984dd46a2e419d85fc00f9e3196b88f21b00efcf3f", + "status": "PASS", + "started_utc": "2026-10-11T23:13:23.545627+00:00", + "finished_utc": "2026-10-11T23:13:25.815989+00:00", + "compile_seconds": 2.2703582440008176, + "queue_seconds": 0.0005492279997270089, + "peak_vm_bytes": 1731051520, + "object_sha256": "2084a5516a72c995fa40f4f424ef2f94f88a0dbaff3fcbdaad153ff24470a503", + "current": true, + "epoch": "20261011" + }, + { + "module": "BinaryCountReceiptAmortization", + "source_sha256": "48f51cf3387fbcd88c75f05bd7714716be33b5590f976a3519fa025ea64bba08", + "receipt_sha256": "2bcdd3f3f58628d1e2a790727df3b84379e6cfdf3dba20e604015109afcd0be4", + "log_sha256": "2732113b6167e7b2d20f6b3944acf349cbfd6b9e4454d082a072c4274f49ca1a", + "status": "PASS", + "started_utc": "2026-10-12T00:20:31.644429+00:00", + "finished_utc": "2026-10-12T00:20:33.653050+00:00", + "compile_seconds": 2.0086102029999893, + "queue_seconds": 0.0010503899993636878, + "process_observations": { + "samples": 20, + "peak_vm_bytes": 1772720128, + "peak_rss_bytes": 1046773760, + "peak_threads": 4 + }, + "peak_vm_bytes": 1772720128, + "object_sha256": "4eb3451b2ab99adf5407556ed95e2cf4e7ff76dc63b9f549152928df445aad37" + } + ], + "complete_axiom_probes": [ + { + "module": "CounterArithmeticPure", + "declaration": "CounterArithmetic.updated_nil", + "axioms": [] + }, + { + "module": "CounterArithmeticPure", + "declaration": "CounterArithmetic.updated_carry", + "axioms": [ + "propext" + ] + }, + { + "module": "CounterArithmeticPure", + "declaration": "CounterArithmetic.updated_stop", + "axioms": [ + "propext" + ] + }, + { + "module": "CounterArithmeticPure", + "declaration": "CounterArithmetic.updated_length", + "axioms": [ + "propext" + ] + }, + { + "module": "CounterArithmeticPure", + "declaration": "CounterArithmetic.carryLength_le_length", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "module": "CounterArithmeticPure", + "declaration": "CounterArithmetic.potential_le_length", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "module": "CounterArithmeticPure", + "declaration": "CounterArithmetic.potential_accounting", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "module": "CounterArithmeticPure", + "declaration": "CounterArithmetic.amortized_step", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "module": "CounterArithmeticPure", + "declaration": "CounterArithmetic.iterate_length", + "axioms": [ + "propext" + ] + }, + { + "module": "CounterArithmeticPure", + "declaration": "CounterArithmetic.amortized_total", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "module": "CounterArithmeticPure", + "declaration": "CounterArithmetic.total_steps_bound", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "module": "CounterArithmeticPure", + "declaration": "CounterArithmetic.value_bound", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "module": "CounterArithmeticPure", + "declaration": "CounterArithmetic.increment_value", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "module": "CounterArithmeticPure", + "declaration": "CounterArithmetic.decrement_value", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "module": "CounterArithmeticPure", + "declaration": "CounterArithmetic.decrement_underflow_iff_zero", + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ] + }, + { + "module": "CounterArithmeticPure", + "declaration": "CounterArithmetic.overflow_updated", + "axioms": [ + "propext" + ] + }, + { + "module": "CounterArithmeticPure", + "declaration": "CounterArithmetic.zero_replicate_value", + "axioms": [ + "propext" + ] + }, + { + "module": "CounterArithmeticPure", + "declaration": "CounterArithmetic.increment_overflow_iff_max", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "module": "CounterArithmeticPure", + "declaration": "CounterArithmetic.decrement_positive", + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ] + }, + { + "module": "CounterArithmeticPure", + "declaration": "CounterArithmetic.countdown_value", + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ] + }, + { + "module": "CounterArithmeticPure", + "declaration": "CounterArithmetic.countdown_not_finished", + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ] + }, + { + "module": "CounterArithmeticPure", + "declaration": "CounterArithmetic.countdown_final_underflow", + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ] + }, + { + "module": "CounterArithmeticPure", + "declaration": "CounterArithmetic.complete_block_cost", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "module": "IntegerConvolution", + "declaration": "CurrentMain.IntegerConvolution.value_addCoefficients", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "module": "IntegerConvolution", + "declaration": "CurrentMain.IntegerConvolution.value_map_mul", + "axioms": [ + "propext" + ] + }, + { + "module": "IntegerConvolution", + "declaration": "CurrentMain.IntegerConvolution.convolution_value", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "module": "IntegerConvolution", + "declaration": "CurrentMain.IntegerConvolution.binary_convolution", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "module": "FixedTapeMachine", + "declaration": "CurrentMain.FixedTapeMachine.initial_inputA", + "axioms": [ + "propext" + ] + }, + { + "module": "FixedTapeMachine", + "declaration": "CurrentMain.FixedTapeMachine.initial_inputB", + "axioms": [ + "propext" + ] + }, + { + "module": "FixedTapeMachine", + "declaration": "CurrentMain.FixedTapeMachine.initial_output", + "axioms": [ + "propext" + ] + }, + { + "module": "FixedTapeMachine", + "declaration": "CurrentMain.FixedTapeMachine.run_halted", + "axioms": [] + }, + { + "module": "FixedTapeMachine", + "declaration": "CurrentMain.FixedTapeMachine.run_add", + "axioms": [ + "propext" + ] + }, + { + "module": "CarryTape", + "declaration": "CurrentMain.CarryTape.run_add", + "axioms": [ + "propext" + ] + }, + { + "module": "CarryTape", + "declaration": "CurrentMain.CarryTape.carry_execution", + "axioms": [ + "propext" + ] + }, + { + "module": "CarryTape", + "declaration": "CurrentMain.CarryTape.rewind_execution", + "axioms": [ + "propext" + ] + }, + { + "module": "CarryTape", + "declaration": "CurrentMain.CarryTape.carryFinish_rewind", + "axioms": [ + "propext" + ] + }, + { + "module": "CarryTape", + "declaration": "CurrentMain.CarryTape.increment_execution", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "module": "CarryTape", + "declaration": "CurrentMain.CarryTape.increment_length", + "axioms": [ + "propext" + ] + }, + { + "module": "CarryTape", + "declaration": "CurrentMain.CarryTape.all_ones_execution", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "module": "CarryTapePass", + "declaration": "CurrentMain.CarryTape.value_bound", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "module": "CarryTapePass", + "declaration": "CurrentMain.CarryTape.increment_value", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "module": "CarryTapePass", + "declaration": "CurrentMain.CarryTape.increment_mod", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "module": "CarryTapePass", + "declaration": "CurrentMain.CarryTape.pass_length", + "axioms": [ + "propext" + ] + }, + { + "module": "CarryTapePass", + "declaration": "CurrentMain.CarryTape.pass_value", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "module": "CarryTapePass", + "declaration": "CurrentMain.CarryTape.pass_even", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "module": "CarryTapePass", + "declaration": "CurrentMain.CarryTape.empty_pass_one", + "axioms": [] + }, + { + "module": "CarryTapePass", + "declaration": "CurrentMain.CarryTape.complete_pass", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "module": "CarryTapePass", + "declaration": "CurrentMain.CarryTape.incrementReceipt_realized", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "module": "CarryTapePass", + "declaration": "CurrentMain.CarryTape.pass_successor_realized", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "module": "CarryTapePass", + "declaration": "CurrentMain.CarryTape.full_pass24_index_traffic", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "module": "BinaryCarryIncrement", + "declaration": "CurrentMain.BinaryCarryIncrement.increment_run", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "module": "BinaryCarryIncrement", + "declaration": "CurrentMain.BinaryCarryIncrement.final_halted", + "axioms": [ + "propext" + ] + }, + { + "module": "BinaryCarryIncrement", + "declaration": "CurrentMain.BinaryCarryIncrement.increment_length", + "axioms": [ + "propext" + ] + }, + { + "module": "BinaryCarryIncrement", + "declaration": "CurrentMain.BinaryCarryIncrement.value_binding", + "axioms": [] + }, + { + "module": "BinaryCarryIncrement", + "declaration": "CurrentMain.BinaryCarryIncrement.increment_modular_value", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "module": "BinaryCountDispatcher", + "declaration": "CurrentMain.BinaryCountDispatcher.count_run", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "module": "BinaryCountDispatcher", + "declaration": "CurrentMain.BinaryCountDispatcher.final_halted", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "module": "BinaryCountDispatcher", + "declaration": "CurrentMain.BinaryCountDispatcher.counter_length", + "axioms": [ + "propext" + ] + }, + { + "module": "BinaryCountDispatcher", + "declaration": "CurrentMain.BinaryCountDispatcher.counter_value", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "module": "BinaryCountDispatcherMarkedInput", + "declaration": "CurrentMain.BinaryCountDispatcherMarkedInput.count_run", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "module": "BinaryCountDispatcherMarkedInput", + "declaration": "CurrentMain.BinaryCountDispatcherMarkedInput.final_halted", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "module": "BinaryCountDispatcherMarkedInput", + "declaration": "CurrentMain.BinaryCountDispatcherMarkedInput.counter_length", + "axioms": [ + "propext" + ] + }, + { + "module": "BinaryCountDispatcherMarkedInput", + "declaration": "CurrentMain.BinaryCountDispatcherMarkedInput.counter_value", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "module": "BinaryCounterZeroAllocation", + "declaration": "CurrentMain.BinaryCounterZeroAllocation.allocate_run_exact", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "module": "BinaryCounterZeroAllocation", + "declaration": "CurrentMain.BinaryCounterZeroAllocation.final_halted", + "axioms": [ + "propext" + ] + }, + { + "module": "BinaryCounterZeroAllocation", + "declaration": "CurrentMain.BinaryCounterZeroAllocation.allocated_width", + "axioms": [ + "propext" + ] + }, + { + "module": "BinaryAutomaticWidthCount", + "declaration": "CurrentMain.BinaryAutomaticWidthCount.count_run", + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ] + }, + { + "module": "BinaryAutomaticWidthCount", + "declaration": "CurrentMain.BinaryAutomaticWidthCount.final_halted", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "module": "BinaryAutomaticWidthCount", + "declaration": "CurrentMain.BinaryAutomaticWidthCount.final_input", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "module": "BinaryAutomaticWidthCount", + "declaration": "CurrentMain.BinaryAutomaticWidthCount.final_counter", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "module": "BinaryAutomaticWidthCount", + "declaration": "CurrentMain.BinaryAutomaticWidthCount.counter_width", + "axioms": [ + "propext" + ] + }, + { + "module": "BinaryAutomaticWidthCount", + "declaration": "CurrentMain.BinaryAutomaticWidthCount.counter_value", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "module": "BinaryCountReceiptAmortization", + "declaration": "CurrentMain.BinaryCountReceiptAmortization.prefix_binding", + "axioms": [ + "propext" + ] + }, + { + "module": "BinaryCountReceiptAmortization", + "declaration": "CurrentMain.BinaryCountReceiptAmortization.increment_binding", + "axioms": [ + "propext" + ] + }, + { + "module": "BinaryCountReceiptAmortization", + "declaration": "CurrentMain.BinaryCountReceiptAmortization.increment_reads_binding", + "axioms": [ + "propext" + ] + }, + { + "module": "BinaryCountReceiptAmortization", + "declaration": "CurrentMain.BinaryCountReceiptAmortization.pass_result_binding", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "module": "BinaryCountReceiptAmortization", + "declaration": "CurrentMain.BinaryCountReceiptAmortization.pass_reads_binding", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "module": "BinaryCountReceiptAmortization", + "declaration": "CurrentMain.BinaryCountReceiptAmortization.pass_reads_le", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "module": "BinaryCountReceiptAmortization", + "declaration": "CurrentMain.BinaryCountReceiptAmortization.count_run_linear", + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ] + } + ], + "closure_probe_count": 79, + "acceptance_sha256": "0240d296078cbd063d9318291bfff1b50fc9a8e3240f23fd0965819cdbea38ed", + "independent_review_sha256": "fe9953b31332c197d1aaf462a61ed160c95e3f248adfbef583449c7cbb14b42e", + "comment_transition_sha256": "f115451ff6a08980b64382581c895bc52bf05a9ff12cdb79dda0fc8abf49172d", + "public_replay_summary_sha256": "274c3dc5c100dd125ef41af06778cde816faf70da321aced4e5fa55eb04fffd0" +} diff --git a/research/lean-count-receipt-amortization/AUTHOR_CHECK.json b/research/lean-count-receipt-amortization/AUTHOR_CHECK.json new file mode 100644 index 0000000000..3bafe9535a --- /dev/null +++ b/research/lean-count-receipt-amortization/AUTHOR_CHECK.json @@ -0,0 +1,15 @@ +{ + "status": "EXACT_PUBLIC_AUTHOR_SCOPE_AND_REPRODUCTION_CONFIRMED", + "author_draft_sha256": "c4565ad0e57987ce606a1e8ac921d12beab17cf3e33c3cf4712235e5db3364f8", + "source_scope_sha256": "4ba7d5d47122bc35d0a2acafd13f4a5f5104269be627881d02d2ba16238878f4", + "kappa": "90446448750933/125000000000000000", + "decimal": "0.000723571590007464", + "source_base": "12a4934d15006e8c10f9b2264f13f8f341be802b", + "public_replay": "Completed guarded resumed twelve-source reproduction; all79 probes verified and final replay-status author readback confirmed", + "staged_package_author_sha256": "40e5601ede740cb9cb1519cddac0ab9073bef706bfc72497d303f7e064ce9ae6", + "scope_and_comment_independent_review_sha256": "5fa1dfa0788b161367329877ba8b76fb2831091b0d397095b56e63131934be3c", + "notice_opener_author_readback_sha256": "aed5c48a21dd66f801c6aedc4d4773bb9f9519b240c578f00c66d2aa8ea0d551", + "final_replay_status_author_sha256": "e9fb8107cbd71cfbb55584f5a00b919eee8a4ee2149e74fe521dcc6d1b9afcce", + "replay_terminal_independent_review_sha256": "90f777de82f52f009672a250c0c2adc67fd8f6f99ae3b6f47084d465246acb25", + "replay_summary_sha256": "274c3dc5c100dd125ef41af06778cde816faf70da321aced4e5fa55eb04fffd0" +} diff --git a/research/lean-count-receipt-amortization/BinaryCountReceiptAmortization.lean b/research/lean-count-receipt-amortization/BinaryCountReceiptAmortization.lean new file mode 100644 index 0000000000..60156bee04 --- /dev/null +++ b/research/lean-count-receipt-amortization/BinaryCountReceiptAmortization.lean @@ -0,0 +1,96 @@ +import CounterArithmeticPure +import BinaryAutomaticWidthCount + +/-! Arithmetic transport from the existing PR64 fixed-direction counter bound. +The published TapeStack, RippleCounter and CounterArithmetic source files are +unchanged. Only the literal prefix/update/iteration interfaces are identified. +The marked-home increment receipt costs two more transitions than PR64's +restored-digit receipt, so current pass reads equal published totalSteps+2N. +The published4N+2w theorem then gives6N+2w and the accepted automatic-width +machine obtains the loose linear bound12n+4. No new potential argument, generic +counter algorithm or full tape-model simulation is asserted. Compact output, +source caller/Plan and selected asymptotic/kappa instantiation remain separate. -/ +namespace CurrentMain.BinaryCountReceiptAmortization +open FixedTapeMachine + +/-- The two literal prefix functions select exactly the same true-bit run. -/ +theorem prefix_binding (bits : List Bool) : + CarryTape.trailingOnes bits=RippleCounter.carryLength true bits := by + induction bits with + | nil => rfl + | cons b bits ih => + cases b <;> simp [CarryTape.trailingOnes,RippleCounter.carryLength,ih] + +/-- Reuse the published update equations, rather than prove increment +correctness or potential accounting again. -/ +theorem increment_binding (bits : List Bool) : + CarryTape.increment bits=RippleCounter.updated true bits := by + induction bits with + | nil => rfl + | cons b bits ih => + cases b with + | false => + rw [CounterArithmetic.updated_stop true false bits (by decide)] + rfl + | true => + rw [CounterArithmetic.updated_carry true bits] + change false::CarryTape.increment bits=false::RippleCounter.updated true bits + exact congrArg (List.cons false) ih + +theorem increment_reads_binding (bits : List Bool) : + (CarryTape.incrementReceipt bits).reads=RippleCounter.steps true bits+2 := by + simp only [CarryTape.incrementReceipt,RippleCounter.steps,prefix_binding] + +private theorem pass_binding (n : Nat) (bits : List Bool) : + (CarryTape.pass n bits).1=CounterArithmetic.iterate true n bits ∧ + (CarryTape.pass n bits).2.reads=CounterArithmetic.totalSteps true n bits+2*n := by + induction n generalizing bits with + | zero => + simp [CarryTape.pass,CarryTape.Receipt.zero,CounterArithmetic.iterate,CounterArithmetic.totalSteps] + | succ n ih => + obtain ⟨hv,hr⟩ := ih (CarryTape.increment bits) + constructor + · simp only [CarryTape.pass,CounterArithmetic.iterate] + rw [← increment_binding bits] + exact hv + · simp only [CarryTape.pass,CarryTape.Receipt.add,CounterArithmetic.totalSteps] + rw [hr,increment_reads_binding,increment_binding bits] + omega + +theorem pass_result_binding (n : Nat) (bits : List Bool) : + (CarryTape.pass n bits).1=CounterArithmetic.iterate true n bits := + (pass_binding n bits).1 + +theorem pass_reads_binding (n : Nat) (bits : List Bool) : + (CarryTape.pass n bits).2.reads=CounterArithmetic.totalSteps true n bits+2*n := + (pass_binding n bits).2 + +/-- The existing PR64 theorem applies in the fixed increment direction and +charges the width of an arbitrary initial word. Width0 and wraparound remain +included, with no uncharged initial-potential premise. -/ +theorem pass_reads_le (n : Nat) (bits : List Bool) : + (CarryTape.pass n bits).2.reads≤6*n+2*bits.length := by + have h := CounterArithmetic.total_steps_bound true n bits + rw [pass_reads_binding] + omega + +/-- A concrete linear bound for the already accepted ten-state machine, from +the same right-blank/pristine-counter entry and with the same full endpoint. +It does not supply compact output or an asymptotic multiplication theorem. -/ +theorem count_run_linear (word : List Bool) : + ∃ t≤12*word.length+4, + run BinaryAutomaticWidthCount.machine t (BinaryAutomaticWidthCount.initialConfiguration word)= + BinaryAutomaticWidthCount.finalConfiguration word := by + obtain ⟨t,ht,hr⟩ := BinaryAutomaticWidthCount.count_run word + have hp := pass_reads_le word.length (BinaryAutomaticWidthCount.zeroBits word) + simp only [BinaryAutomaticWidthCount.zeroBits,List.length_replicate] at hp ht + exact ⟨t,by omega,hr⟩ + +end CurrentMain.BinaryCountReceiptAmortization +#print axioms CurrentMain.BinaryCountReceiptAmortization.prefix_binding +#print axioms CurrentMain.BinaryCountReceiptAmortization.increment_binding +#print axioms CurrentMain.BinaryCountReceiptAmortization.increment_reads_binding +#print axioms CurrentMain.BinaryCountReceiptAmortization.pass_result_binding +#print axioms CurrentMain.BinaryCountReceiptAmortization.pass_reads_binding +#print axioms CurrentMain.BinaryCountReceiptAmortization.pass_reads_le +#print axioms CurrentMain.BinaryCountReceiptAmortization.count_run_linear diff --git a/research/lean-count-receipt-amortization/CounterArithmeticPure.lean b/research/lean-count-receipt-amortization/CounterArithmeticPure.lean new file mode 100644 index 0000000000..b4b5a707a2 --- /dev/null +++ b/research/lean-count-receipt-amortization/CounterArithmeticPure.lean @@ -0,0 +1,277 @@ +/- +PR64 upstream attribution and modification notice + +This file adapts CounterArithmetic.lean from the published PR64 counter work: +https://github.com/CrocSwap/integer-mult-bounds/pull/64 +Original path: research/machine-transfer-verification/stream-transfer/counters/CounterArithmetic.lean +Original SHA-256: 00caa87ed92bd65ac6a2535a58faba438f887cc6b137c4cfb28a1df403628554 +The original source is recorded in the publication manifest at current-main +12a4934d15006e8c10f9b2264f13f8f341be802b. + +Modifications: retarget the import to the exact five-definition +RippleCounterListData extraction; locally register the installed Nat.le_refl +and Nat.mul_eq_zero theorems; and select synchronous module elaboration with +Elab.async=false. All original mathematical declaration/proof bodies and +23 axiom probes are retained. The public packaging copy adds only this notice +to the separately accepted adapted source. No new potential proof is claimed. + +Repository license: Apache-2.0. See the accompanying LICENSE, NOTICE and +PROVENANCE.json for attribution, exact correspondence and dependency pins. +-/ + +import RippleCounterListData + +section +set_option Elab.async false +attribute [local refl] Nat.le_refl +attribute [local simp] Nat.mul_eq_zero + +namespace CounterArithmetic +open RippleCounter + +/-- Standard nonnegative value of a little-endian fixed-width binary word. -/ +def value : List Bool → ℕ + | [] => 0 + | b::rest => (if b then 1 else 0) + 2 * value rest + +/-- Amortized credit is the number of bits that propagate this direction's carry. -/ +def potential (d : Bool) : List Bool → ℕ + | [] => 0 + | b::rest => (if b = d then 1 else 0) + potential d rest + +theorem updated_nil (d : Bool) : updated d [] = [] := rfl + +theorem updated_carry (d : Bool) (rest : List Bool) : + updated d (d::rest) = (!d)::updated d rest := by + simp [updated, carryLength, stopTail, List.replicate_succ] + +theorem updated_stop (d b : Bool) (rest : List Bool) (h : b ≠ d) : + updated d (b::rest) = (!b)::rest := by + simp [updated, carryLength, stopTail, h] + +theorem updated_length (d : Bool) (bits : List Bool) : + (updated d bits).length = bits.length := by + induction bits with + | nil => rfl + | cons b rest ih => + by_cases h : b = d + · subst b; rw [updated_carry]; simp [ih] + · rw [updated_stop d b rest h]; rfl + +theorem carryLength_le_length (d : Bool) (bits : List Bool) : + carryLength d bits ≤ bits.length := by + induction bits with + | nil => rfl + | cons b rest ih => + simp only [carryLength, List.length_cons] + split_ifs <;> omega + +theorem potential_le_length (d : Bool) (bits : List Bool) : + potential d bits ≤ bits.length := by + induction bits with + | nil => rfl + | cons b rest ih => + simp only [potential, List.length_cons] + split_ifs <;> omega + +/-- A successful operation replaces k carry bits by k non-carry bits and creates +one carry bit; overflow only deletes carry bits. This includes width zero. -/ +theorem potential_accounting (d : Bool) (bits : List Bool) : + carryLength d bits + potential d (updated d bits) ≤ potential d bits + 1 := by + induction bits with + | nil => simp [carryLength, potential, updated_nil] + | cons b rest ih => + by_cases h : b = d + · subst b + rw [updated_carry] + have hne : (!d) ≠ d := by cases d <;> decide + simp only [carryLength, potential, if_pos, if_neg hne] + omega + · rw [updated_stop d b rest h] + have heq : (!b) = d := by cases b <;> cases d <;> simp_all + simp [carryLength, potential, h, heq, Nat.add_comm] + +theorem amortized_step (d : Bool) (bits : List Bool) : + steps d bits + 2 * potential d (updated d bits) ≤ 4 + 2 * potential d bits := by + have h := potential_accounting d bits + unfold steps + omega + +def iterate (d : Bool) : ℕ → List Bool → List Bool + | 0, bits => bits + | n+1, bits => iterate d n (updated d bits) + +theorem iterate_length (d : Bool) (n : ℕ) (bits : List Bool) : + (iterate d n bits).length = bits.length := by + induction n generalizing bits with + | zero => rfl + | succ n ih => rw [iterate, ih, updated_length] + +def totalSteps (d : Bool) : ℕ → List Bool → ℕ + | 0, _ => 0 + | n+1, bits => steps d bits + totalSteps d n (updated d bits) + +theorem amortized_total (d : Bool) (n : ℕ) (bits : List Bool) : + totalSteps d n bits + 2 * potential d (iterate d n bits) ≤ 4*n + 2 * potential d bits := by + induction n generalizing bits with + | zero => simp [totalSteps, iterate] + | succ n ih => + have h := amortized_step d bits + have hn := ih (updated d bits) + simp only [totalSteps, iterate] + omega + +/-- Total literal head-local counting transitions, including every head return. +Arbitrary starting words are permitted; their initial potential is charged by w. -/ +theorem total_steps_bound (d : Bool) (n : ℕ) (bits : List Bool) : + totalSteps d n bits ≤ 4*n + 2*bits.length := by + have h := amortized_total d n bits + have hp := potential_le_length d bits + omega + +theorem value_bound (bits : List Bool) : value bits < 2 ^ bits.length := by + induction bits with + | nil => simp [value] + | cons b rest ih => + cases b <;> simp only [value, Bool.false_eq_true, ↓reduceIte, List.length_cons, pow_succ] <;> + omega + +/-- Exact modular increment equation; no infinite-precision counter is assumed. -/ +theorem increment_value (bits : List Bool) : + value (updated true bits) + (if overflow true bits then 2^bits.length else 0) = value bits + 1 := by + induction bits with + | nil => simp [updated_nil, value, overflow] + | cons b rest ih => + cases b with + | false => simp [updated_stop, value, overflow, Nat.add_comm] + | true => + rw [updated_carry] + simp only [value, Bool.not_true, Bool.false_eq_true, ↓reduceIte, overflow, + List.length_cons, pow_succ] at * + cases ho : overflow true rest <;> simp [ho] at ih ⊢ <;> omega + +/-- Exact modular decrement equation. Underflow returns all ones and raises +its flag; clients reset from the local template before the next block. -/ +theorem decrement_value (bits : List Bool) : + value bits + (if overflow false bits then 2^bits.length else 0) = value (updated false bits) + 1 := by + induction bits with + | nil => simp [updated_nil, value, overflow] + | cons b rest ih => + cases b with + | false => + rw [updated_carry] + simp only [value, Bool.not_false, Bool.false_eq_true, ↓reduceIte, overflow, + List.length_cons, pow_succ] at * + cases ho : overflow false rest <;> simp [ho] at ih ⊢ <;> omega + | true => simp [updated_stop, value, overflow, Nat.add_comm] + +/-- Underflow detects exactly zero in the INPUT counter, without a separate scan. -/ +theorem decrement_underflow_iff_zero (bits : List Bool) : + overflow false bits = true ↔ value bits = 0 := by + induction bits with + | nil => simp [overflow, value] + | cons b rest ih => + cases b <;> simp [overflow, value, ih] + +theorem overflow_updated (d : Bool) (bits : List Bool) (h : overflow d bits = true) : + updated d bits = List.replicate bits.length (!d) := by + induction bits with + | nil => rfl + | cons b rest ih => + by_cases hb : b = d + · subst b + rw [updated_carry] + simp only [overflow, if_pos] at h + rw [ih h, List.length_cons, List.replicate_succ] + · simp [overflow, hb] at h + +theorem zero_replicate_value (n : ℕ) : value (List.replicate n false) = 0 := by + induction n with + | zero => rfl + | succ n ih => simp [List.replicate_succ, value, ih] + +theorem increment_overflow_iff_max (bits : List Bool) : + overflow true bits = true ↔ value bits + 1 = 2^bits.length := by + have heq := increment_value bits + constructor + · intro h + rw [overflow_updated true bits h] at heq + simpa [h, zero_replicate_value] using heq.symm + · intro h + cases ho : overflow true bits + · have hb := value_bound (updated true bits) + rw [updated_length] at hb + simp [ho] at heq + omega + · rfl + +/-- Every decrement before zero reduces the represented value by exactly one. -/ +theorem decrement_positive (bits : List Bool) (h : 0 < value bits) : + overflow false bits = false ∧ value (updated false bits) + 1 = value bits := by + have hn : overflow false bits ≠ true := by + intro hflag + have := (decrement_underflow_iff_zero bits).mp hflag + omega + have hf : overflow false bits = false := by cases hflag : overflow false bits <;> simp_all + refine ⟨hf, ?_⟩ + have hv := decrement_value bits + simpa [hf] using hv.symm + +theorem countdown_value (bits : List Bool) (n : ℕ) (hn : n ≤ value bits) : + value (iterate false n bits) = value bits - n := by + induction n generalizing bits with + | zero => simp [iterate] + | succ n ih => + have hp : 0 < value bits := by omega + have hv := (decrement_positive bits hp).2 + have hnext : n ≤ value (updated false bits) := by omega + rw [iterate, ih (updated false bits) hnext] + omega + +theorem countdown_not_finished (bits : List Bool) (n : ℕ) (hn : n < value bits) : + overflow false (iterate false n bits) = false := by + have hv := countdown_value bits n (Nat.le_of_lt hn) + apply (decrement_positive (iterate false n bits) (by omega)).1 + +/-- Starting with B-1, the B-th post-emission decrement detects the end of +exactly B payload positions. No comparison against the whole descriptor occurs. -/ +theorem countdown_final_underflow (bits : List Bool) : + overflow false (iterate false (value bits) bits) = true := by + apply (decrement_underflow_iff_zero _).mpr + rw [countdown_value bits (value bits) (Nat.le_refl _)] + omega + +/-- When the locally stored width w is at most block length B, counting B +payload positions including the terminal borrow costs at most 6B transitions. -/ +theorem complete_block_cost (bits : List Bool) (hw : bits.length ≤ value bits + 1) : + totalSteps false (value bits + 1) bits ≤ 6 * (value bits + 1) := by + have h := total_steps_bound false (value bits + 1) bits + omega + +end CounterArithmetic + +#print axioms CounterArithmetic.updated_nil +#print axioms CounterArithmetic.updated_carry +#print axioms CounterArithmetic.updated_stop +#print axioms CounterArithmetic.updated_length +#print axioms CounterArithmetic.carryLength_le_length +#print axioms CounterArithmetic.potential_le_length +#print axioms CounterArithmetic.potential_accounting +#print axioms CounterArithmetic.amortized_step +#print axioms CounterArithmetic.iterate_length +#print axioms CounterArithmetic.amortized_total +#print axioms CounterArithmetic.total_steps_bound +#print axioms CounterArithmetic.value_bound +#print axioms CounterArithmetic.increment_value +#print axioms CounterArithmetic.decrement_value +#print axioms CounterArithmetic.decrement_underflow_iff_zero +#print axioms CounterArithmetic.overflow_updated +#print axioms CounterArithmetic.zero_replicate_value +#print axioms CounterArithmetic.increment_overflow_iff_max +#print axioms CounterArithmetic.decrement_positive +#print axioms CounterArithmetic.countdown_value +#print axioms CounterArithmetic.countdown_not_finished +#print axioms CounterArithmetic.countdown_final_underflow +#print axioms CounterArithmetic.complete_block_cost + +end diff --git a/research/lean-count-receipt-amortization/DEPENDENCIES.json b/research/lean-count-receipt-amortization/DEPENDENCIES.json new file mode 100644 index 0000000000..f8dba4b229 --- /dev/null +++ b/research/lean-count-receipt-amortization/DEPENDENCIES.json @@ -0,0 +1,83 @@ +{ + "pr488": { + "repository": "https://github.com/jamesyc/integer-mult-bounds", + "commit": "edd3102b415df5b9d6f633ac0a4dedcf69c58525", + "pull_request": "https://github.com/CrocSwap/integer-mult-bounds/pull/488", + "package_path": "research/lean-binary-input-preparation", + "merge_assumed": false, + "files": [ + { + "module": "IntegerConvolution", + "repository_path": "research/lean-binary-input-preparation/Lean/IntegerConvolution.lean", + "sha256": "0bc86f2fa8e68f39df77be603d2a9634bc008745093286903105378ab45938ea", + "bytes": 2055 + }, + { + "module": "FixedTapeMachine", + "repository_path": "research/lean-binary-input-preparation/Lean/FixedTapeMachine.lean", + "sha256": "92dadedc9f6e23d12633549b53ca8f917360e4fedac0b64a58d18feea741a5ed", + "bytes": 4523 + } + ] + }, + "pr511": { + "repository": "https://github.com/jamesyc/integer-mult-bounds", + "commit": "79f7c03c7f820ab89955b75ef239cbaccc627e6e", + "pull_request": "https://github.com/CrocSwap/integer-mult-bounds/pull/511", + "package_path": "research/lean-binary-count-dispatcher", + "merge_assumed": false, + "files": [ + { + "module": "CarryTape", + "repository_path": "research/lean-binary-count-dispatcher/CarryTape.lean", + "sha256": "20d13d9d2da74452e45c0a175b643556615ba14187bf8fb0e4393e44842c17a5", + "bytes": 8348 + }, + { + "module": "CarryTapePass", + "repository_path": "research/lean-binary-count-dispatcher/CarryTapePass.lean", + "sha256": "680b5d16736880ac6a02f27e9503e1cc01479bb2b35bb7546d9108dcb4b4ef2b", + "bytes": 5662 + }, + { + "module": "BinaryCarryIncrement", + "repository_path": "research/lean-binary-count-dispatcher/BinaryCarryIncrement.lean", + "sha256": "b0f639159e2169c75e6d7a13663adee5107648a32b7ff9203f92792e31012dce", + "bytes": 9032 + }, + { + "module": "BinaryCountDispatcher", + "repository_path": "research/lean-binary-count-dispatcher/BinaryCountDispatcher.lean", + "sha256": "ec24af9483d59ce3248802378218d4b478490aa2458e136880f36e7f49356e93", + "bytes": 14544 + } + ] + }, + "pr519": { + "repository": "https://github.com/jamesyc/integer-mult-bounds", + "commit": "ffd3c48a80ba8b579dc300e785e387fe8acddfef", + "pull_request": "https://github.com/CrocSwap/integer-mult-bounds/pull/519", + "package_path": "research/lean-automatic-width-count", + "merge_assumed": false, + "files": [ + { + "module": "BinaryCountDispatcherMarkedInput", + "repository_path": "research/lean-automatic-width-count/BinaryCountDispatcherMarkedInput.lean", + "sha256": "b7f0cecb69194b8d851037e8321e245dc383c62e3e2475c9d4508d29390191cc", + "bytes": 10257 + }, + { + "module": "BinaryCounterZeroAllocation", + "repository_path": "research/lean-automatic-width-count/BinaryCounterZeroAllocation.lean", + "sha256": "5cf3fdfcd6c6a6cefa89b9a83dc678b6f40d9a608c318334ae92a66d25ea7477", + "bytes": 9595 + }, + { + "module": "BinaryAutomaticWidthCount", + "repository_path": "research/lean-automatic-width-count/BinaryAutomaticWidthCount.lean", + "sha256": "5dcf4ec74f08d9662738db413d144e16f4b555e56f29e0846ad5c88726420154", + "bytes": 10124 + } + ] + } +} diff --git a/research/lean-count-receipt-amortization/EXTERNAL_OBJECTS.json b/research/lean-count-receipt-amortization/EXTERNAL_OBJECTS.json new file mode 100644 index 0000000000..d3dc7545a9 --- /dev/null +++ b/research/lean-count-receipt-amortization/EXTERNAL_OBJECTS.json @@ -0,0 +1,20076 @@ +{ + "format": "exact-accepted-runtime-closure-v1", + "lean_version": "4.21.0", + "lean_binary_sha256": "cbf5fd536e142ef1beaccf33f788fd8a7f3f29fb214e75c11319a8d8677b4b2b", + "mathlib_commit": "308445d7985027f538e281e18df29ca16ede2ba3", + "library_paths_relative_to_mathlib": [ + ".lake/build/lib/lean", + ".lake/packages/LeanSearchClient/.lake/build/lib/lean", + ".lake/packages/Qq/.lake/build/lib/lean", + ".lake/packages/aesop/.lake/build/lib/lean", + ".lake/packages/batteries/.lake/build/lib/lean", + ".lake/packages/importGraph/.lake/build/lib/lean", + ".lake/packages/plausible/.lake/build/lib/lean", + ".lake/packages/proofwidgets/.lake/build/lib/lean" + ], + "modules": [ + { + "module": "Init.Prelude", + "root": "lean", + "source_path": "src/lean/Init/Prelude.lean", + "source_sha256": "1c7e90be488584bde36df22c82f632f28338b4ab22040e3e20fc22af95c4edb3", + "object_path": "lib/lean/Init/Prelude.olean", + "object_sha256": "ea380a630b1099b6c4aebcb71d9fdad26ff99a85a4f3e039eefccaf122f33957", + "object_bytes": 3282632, + "imports": [] + }, + { + "module": "Init.Coe", + "root": "lean", + "source_path": "src/lean/Init/Coe.lean", + "source_sha256": "4a8cfeb53a9ff6bc520c3cdb213996ccf5f689e3c08d7f376ad38fa4ae66c413", + "object_path": "lib/lean/Init/Coe.olean", + "object_sha256": "11b4ec1e80b4b3d673ebef984e6d261f34238969865cafb24dbc26fcf2db4d77", + "object_bytes": 233408, + "imports": [ + "Init.Prelude" + ] + }, + { + "module": "Init.Notation", + "root": "lean", + "source_path": "src/lean/Init/Notation.lean", + "source_sha256": "8b97dba761a80d12b9ac8f8848f71e9a99d75a6b2252cf0b52cd798d90ea706b", + "object_path": "lib/lean/Init/Notation.olean", + "object_sha256": "d1ec53dcc253efd3b86c3444ebe9f111aa76a5c43dd4f8eed0692ab5fa3735ac", + "object_bytes": 1705576, + "imports": [ + "Init.Prelude", + "Init.Coe" + ] + }, + { + "module": "Init.Tactics", + "root": "lean", + "source_path": "src/lean/Init/Tactics.lean", + "source_sha256": "a90a98b54fcf690053ee2125e46ce4c39e5ad46712629eae1c72460d1f5494d4", + "object_path": "lib/lean/Init/Tactics.olean", + "object_sha256": "71508476eb2581a386f835cb8f5fd840feb8513ab37959d9c148ae63daebaa58", + "object_bytes": 1913848, + "imports": [ + "Init.Notation" + ] + }, + { + "module": "Init.SizeOf", + "root": "lean", + "source_path": "src/lean/Init/SizeOf.lean", + "source_sha256": "7afbeb525d273a4cf5c0d76e03a72b932800e4d49b1cadd0ee08b2bb1f870b50", + "object_path": "lib/lean/Init/SizeOf.olean", + "object_sha256": "4c6da5579aea51d3a4b8630d0ab0e20c0875c0b3a765dd24425c3fb84f69df5e", + "object_bytes": 166496, + "imports": [ + "Init.Tactics" + ] + }, + { + "module": "Init.Core", + "root": "lean", + "source_path": "src/lean/Init/Core.lean", + "source_sha256": "9e8a954c556bcf150c7908ec8bdf5e06b251c79fdb4c0d0c74c057afd929856f", + "object_path": "lib/lean/Init/Core.olean", + "object_sha256": "67b5b4edb12b6d43e8d13e52bd8b218da8582aae1100b00780c36eba7da586d4", + "object_bytes": 1784808, + "imports": [ + "Init.Prelude", + "Init.SizeOf" + ] + }, + { + "module": "Init.BinderNameHint", + "root": "lean", + "source_path": "src/lean/Init/BinderNameHint.lean", + "source_sha256": "b2b28c6a5cb7ca23144ea7c9f974f4f98b8ea67b05fa4673341f0fdfc8969b5d", + "object_path": "lib/lean/Init/BinderNameHint.olean", + "object_sha256": "c34df0499dce2cae75952db65ed9717109f95910625718fb69eb4abd5d529c37", + "object_bytes": 25920, + "imports": [ + "Init.Prelude", + "Init.Tactics" + ] + }, + { + "module": "Init.Control.Basic", + "root": "lean", + "source_path": "src/lean/Init/Control/Basic.lean", + "source_sha256": "a5237954e95694b41cfea82800ac9f2cea3cccfb58ce0c11940438f923731451", + "object_path": "lib/lean/Init/Control/Basic.olean", + "object_sha256": "5a07ef85466b2eefcd5ed7c7ca572a27c587525e916f623e64652785b3501862", + "object_bytes": 354312, + "imports": [ + "Init.Core", + "Init.BinderNameHint" + ] + }, + { + "module": "Init.Control.Id", + "root": "lean", + "source_path": "src/lean/Init/Control/Id.lean", + "source_sha256": "7f1151b8191cd42ff80d5489eb87ba212fb06dd81470fcbc54c3963d9707758c", + "object_path": "lib/lean/Init/Control/Id.olean", + "object_sha256": "0bddc8884a8f99f8c849e878287a8ba455d8099fc61c5104299853aa62ed10ae", + "object_bytes": 52784, + "imports": [ + "Init.Core" + ] + }, + { + "module": "Init.Control.Except", + "root": "lean", + "source_path": "src/lean/Init/Control/Except.lean", + "source_sha256": "1a3ac01425d54a942c20a736c632fa9eefcf9406a0cf0dfef08ddc3554509895", + "object_path": "lib/lean/Init/Control/Except.olean", + "object_sha256": "95f4a3805c224176612ad3f5b73e3f1f7883899123086e899095bf4cc9783c90", + "object_bytes": 334272, + "imports": [ + "Init.Control.Basic", + "Init.Control.Id", + "Init.Coe" + ] + }, + { + "module": "Init.Control.State", + "root": "lean", + "source_path": "src/lean/Init/Control/State.lean", + "source_sha256": "8de0950e88ffe695054bfab6aea8227662f1ce0fea9e42305d7118e43b86b76f", + "object_path": "lib/lean/Init/Control/State.olean", + "object_sha256": "f586deb8b93271292e986f95bcc650f1ac6768ba4daf3713a58460f309f0b594", + "object_bytes": 257880, + "imports": [ + "Init.Control.Basic", + "Init.Control.Id", + "Init.Control.Except" + ] + }, + { + "module": "Init.Data.Cast", + "root": "lean", + "source_path": "src/lean/Init/Data/Cast.lean", + "source_sha256": "704f68e63bf4aa705f6a1ab80dc5d06fe0d4637d29ec60481c8421c92c30b838", + "object_path": "lib/lean/Init/Data/Cast.olean", + "object_sha256": "72c50c7b62d8769cec68f534427f8f737c49099b68bcafee6e787d00ba084062", + "object_bytes": 40152, + "imports": [ + "Init.Coe" + ] + }, + { + "module": "Init.SimpLemmas", + "root": "lean", + "source_path": "src/lean/Init/SimpLemmas.lean", + "source_sha256": "8432fc0a6b37d0708b99a94ab06e49d783191751d6aa1d79ce05396417179773", + "object_path": "lib/lean/Init/SimpLemmas.olean", + "object_sha256": "c80eac0455c1395cc9de931e554b6b889e4db7083396d54ca7b9d767f9cc399f", + "object_bytes": 153568, + "imports": [ + "Init.Core" + ] + }, + { + "module": "Init.Data.Zero", + "root": "lean", + "source_path": "src/lean/Init/Data/Zero.lean", + "source_sha256": "a61743b2d4ea3cf1938dab32ebc3c4e696d421dd30476d7fed25b4c2566f6713", + "object_path": "lib/lean/Init/Data/Zero.olean", + "object_sha256": "c1f5bbd0fb43a6acf73b494e3b040638c255dd77efab570450ee2af71547aca8", + "object_bytes": 54408, + "imports": [ + "Init.Core" + ] + }, + { + "module": "Init.Data.NeZero", + "root": "lean", + "source_path": "src/lean/Init/Data/NeZero.lean", + "source_sha256": "3be9932dffcbedbc0e9e3f2b42bc3a90ec5d4d72ac8c9ba50e13545ac3933a9d", + "object_path": "lib/lean/Init/Data/NeZero.olean", + "object_sha256": "d3db1727955cf3d179f8089d01a05e0a8d15b941440acca62fb43a8ab97ad9d3", + "object_bytes": 66592, + "imports": [ + "Init.Data.Zero" + ] + }, + { + "module": "Init.Grind.Tactics", + "root": "lean", + "source_path": "src/lean/Init/Grind/Tactics.lean", + "source_sha256": "323076c3aee943d1257958bd4c7b8f377a3ce41253a31e8e9a7c9020d63e4aa3", + "object_path": "lib/lean/Init/Grind/Tactics.olean", + "object_sha256": "ca05d873460c2be529d1ac47d0ff0311b935b8c7f950ceb6527aa53c8a1b7029", + "object_bytes": 362064, + "imports": [ + "Init.Tactics" + ] + }, + { + "module": "Init.Data.Nat.Basic", + "root": "lean", + "source_path": "src/lean/Init/Data/Nat/Basic.lean", + "source_sha256": "852fb5877a6947fa7a524ba482c29c61763a502a70235df06b3c49c8c8be14ae", + "object_path": "lib/lean/Init/Data/Nat/Basic.olean", + "object_sha256": "e8bc0a4c16603272b84fd063ca1c2974b87abf6cd936b5deb127ec36393a911e", + "object_bytes": 504304, + "imports": [ + "Init.SimpLemmas", + "Init.Data.NeZero", + "Init.Grind.Tactics" + ] + }, + { + "module": "Init.WF", + "root": "lean", + "source_path": "src/lean/Init/WF.lean", + "source_sha256": "3936fdbe9cebdef5d9f37947a7710102bf3c21d58b304a37d46644fb88112a7d", + "object_path": "lib/lean/Init/WF.olean", + "object_sha256": "afeeb495efbed54193a4db2d14ad2eaeb54bfe10d31de9df1a3cb3bef7f17e04", + "object_bytes": 295504, + "imports": [ + "Init.SizeOf", + "Init.BinderNameHint", + "Init.Data.Nat.Basic" + ] + }, + { + "module": "Init.MetaTypes", + "root": "lean", + "source_path": "src/lean/Init/MetaTypes.lean", + "source_sha256": "0b7417d436b26c9e1148615205ad7da7c75647e78b0a7ad4dd8b8226ad6c8e4c", + "object_path": "lib/lean/Init/MetaTypes.olean", + "object_sha256": "700d3ee1e4176c1bd96a58897212ec1ba61d4dd03893002410a99dc9d0c3cc6a", + "object_bytes": 445968, + "imports": [ + "Init.Core" + ] + }, + { + "module": "Init.WFTactics", + "root": "lean", + "source_path": "src/lean/Init/WFTactics.lean", + "source_sha256": "564db0977991b27bba0075c3e2c49ea902c50bda25f69dce98443f85dc163066", + "object_path": "lib/lean/Init/WFTactics.olean", + "object_sha256": "4ade5cad8925331057b347ab0833766f064a3d70dbc3aed94976ee0f12ae95c1", + "object_bytes": 380256, + "imports": [ + "Init.SizeOf", + "Init.MetaTypes", + "Init.WF" + ] + }, + { + "module": "Init.Data.Nat.Div.Basic", + "root": "lean", + "source_path": "src/lean/Init/Data/Nat/Div/Basic.lean", + "source_sha256": "70cd97084af599f4a8c9d5f07459201244a7d644b99a1cd8b3ef6e4b121a3bd3", + "object_path": "lib/lean/Init/Data/Nat/Div/Basic.olean", + "object_sha256": "fa63266dfb14cbf576ce01382c2ad790ff8e5db9757918a03cfb25daa015711c", + "object_bytes": 208664, + "imports": [ + "Init.WF", + "Init.WFTactics", + "Init.Data.Nat.Basic" + ] + }, + { + "module": "Init.Data.Int.Basic", + "root": "lean", + "source_path": "src/lean/Init/Data/Int/Basic.lean", + "source_sha256": "c19d5921391935deb373ae0b54c05b7d59617e556598d6644125712d73db06b1", + "object_path": "lib/lean/Init/Data/Int/Basic.olean", + "object_sha256": "d77e39a844b64d3c2f38ff22ead779aeb56aff3504e531904288452c52f28094", + "object_bytes": 231944, + "imports": [ + "Init.Data.Cast", + "Init.Data.Nat.Div.Basic" + ] + }, + { + "module": "Init.Data.List.Notation", + "root": "lean", + "source_path": "src/lean/Init/Data/List/Notation.lean", + "source_sha256": "3a320ffa23d956324317e9f00ddeaa720e95016a2e00e69f8d7e00c2c88b2970", + "object_path": "lib/lean/Init/Data/List/Notation.olean", + "object_sha256": "baf7be257c634c72d19e8868579b923ddf0340855f0fba387d2294b6ace6400c", + "object_bytes": 121480, + "imports": [ + "Init.Data.Nat.Div.Basic" + ] + }, + { + "module": "Init.Data.List.Basic", + "root": "lean", + "source_path": "src/lean/Init/Data/List/Basic.lean", + "source_sha256": "3622990991094fa2ea739b1a2c44bcde45913c1bbec75c6c1ebad24e1d1e4175", + "object_path": "lib/lean/Init/Data/List/Basic.olean", + "object_sha256": "9d8c9ce641d43eab2dc15ca1cf1a2c430ce9b974b75e4d4eb773c6ebfef0f209", + "object_bytes": 2181992, + "imports": [ + "Init.SimpLemmas", + "Init.Data.Nat.Basic", + "Init.Data.List.Notation" + ] + }, + { + "module": "Init.Data.Nat.Bitwise.Basic", + "root": "lean", + "source_path": "src/lean/Init/Data/Nat/Bitwise/Basic.lean", + "source_sha256": "21c75e6dd00e5b9535210da4ebfc79a4cd779ee9bbc80c223012ed3a3e93fa3c", + "object_path": "lib/lean/Init/Data/Nat/Bitwise/Basic.olean", + "object_sha256": "abc0cd1bf4fea066d79a0c4e72415067edc3d27134ba22b7b4cceb2bd2254609", + "object_bytes": 87080, + "imports": [ + "Init.Data.Nat.Basic", + "Init.Data.Nat.Div.Basic", + "Init.Coe" + ] + }, + { + "module": "Init.Data.Fin.Basic", + "root": "lean", + "source_path": "src/lean/Init/Data/Fin/Basic.lean", + "source_sha256": "d059acbde8bcb574b5b63a3116af27abb1cadcbcd27efa70548d4e673b78f7bf", + "object_path": "lib/lean/Init/Data/Fin/Basic.olean", + "object_sha256": "76681264095c5bc1fbce28fdf54a30d1b0a020fb7f9b37c18e76f6ef86b837ef", + "object_bytes": 202392, + "imports": [ + "Init.Data.Nat.Bitwise.Basic" + ] + }, + { + "module": "Init.Data.BitVec.BasicAux", + "root": "lean", + "source_path": "src/lean/Init/Data/BitVec/BasicAux.lean", + "source_sha256": "5b8a13509286d776b1b0a7781e5eac5a1318cc3e00f8978f1dbb9ba91c2b5283", + "object_path": "lib/lean/Init/Data/BitVec/BasicAux.olean", + "object_sha256": "d0703afffa8b7d65abf0d3a9640ddf767fa6400f6c61d7c25a8b16f362399f91", + "object_bytes": 39872, + "imports": [ + "Init.Data.Fin.Basic" + ] + }, + { + "module": "Init.Data.UInt.BasicAux", + "root": "lean", + "source_path": "src/lean/Init/Data/UInt/BasicAux.lean", + "source_sha256": "a3189030aa55482e7219bbe9daf30420c6563bcbcade22873798f953ffdd37d3", + "object_path": "lib/lean/Init/Data/UInt/BasicAux.olean", + "object_sha256": "ca066d84641e43dcd7a46040418790ea158a0ad0b4335ff47e06375e5d55b434", + "object_bytes": 136376, + "imports": [ + "Init.Data.Fin.Basic", + "Init.Data.BitVec.BasicAux" + ] + }, + { + "module": "Init.Data.Char.Basic", + "root": "lean", + "source_path": "src/lean/Init/Data/Char/Basic.lean", + "source_sha256": "5f8208d7700d40fcc2aeb60d5358c2d9f2b0036ba3a9155eeb49a10093b3ae11", + "object_path": "lib/lean/Init/Data/Char/Basic.olean", + "object_sha256": "91235dc2441193a6e16a22e7ee1262567fcd7c7b3e6129048bf13823295d847c", + "object_bytes": 93064, + "imports": [ + "Init.Data.UInt.BasicAux" + ] + }, + { + "module": "Init.Data.String.Basic", + "root": "lean", + "source_path": "src/lean/Init/Data/String/Basic.lean", + "source_sha256": "21f7163968bc43a35f8488b0a05df30398d227739e0f70f759c93c77cb2fe8c7", + "object_path": "lib/lean/Init/Data/String/Basic.olean", + "object_sha256": "482c943b9039ea2fd40d87f82d8ae319169de794660126f1fd7bed913a76ec67", + "object_bytes": 1035512, + "imports": [ + "Init.Data.List.Basic", + "Init.Data.Char.Basic" + ] + }, + { + "module": "Init.Data.Format.Basic", + "root": "lean", + "source_path": "src/lean/Init/Data/Format/Basic.lean", + "source_sha256": "982db64c9cfed2fa4f0f9c3b42ae5a1fbb7201afaa1c75722e24ffdbedc5d826", + "object_path": "lib/lean/Init/Data/Format/Basic.olean", + "object_sha256": "3ed1f8192ba357cd4060014aad9d2af5ed578616a75b7d33dbe95e5c50d5804e", + "object_bytes": 795904, + "imports": [ + "Init.Control.State", + "Init.Data.Int.Basic", + "Init.Data.String.Basic" + ] + }, + { + "module": "Init.Data.Repr", + "root": "lean", + "source_path": "src/lean/Init/Data/Repr.lean", + "source_sha256": "a9789d9e79aaa04d3f1dc00ba07a51b5e34b9755c1ccf07412eb5911551f7248", + "object_path": "lib/lean/Init/Data/Repr.olean", + "object_sha256": "9d83d97174fb2dc32dd713e642d6de83bd472a6b65251574473d2446ce023d0a", + "object_bytes": 465320, + "imports": [ + "Init.Data.Format.Basic" + ] + }, + { + "module": "Init.Data.Option.Basic", + "root": "lean", + "source_path": "src/lean/Init/Data/Option/Basic.lean", + "source_sha256": "706b62dbae1aa972df7fc89b6436f6824b10d2109bc234e3865cfa98ffe9f74e", + "object_path": "lib/lean/Init/Data/Option/Basic.olean", + "object_sha256": "81eaf56660353e8fa3577a0057eb79defc4a7fe98e6a8d6c12bfbc8cac26bc81", + "object_bytes": 391056, + "imports": [ + "Init.Control.Basic" + ] + }, + { + "module": "Init.Data.ToString.Basic", + "root": "lean", + "source_path": "src/lean/Init/Data/ToString/Basic.lean", + "source_sha256": "d3674a52ef077a0c5c5187a555e7455f054253b77614c492117984ac7f015680", + "object_path": "lib/lean/Init/Data/ToString/Basic.olean", + "object_sha256": "2a08d61852e736f5b586f15729d5e05bde297117155d77f3da1a4a819d39b257", + "object_bytes": 230416, + "imports": [ + "Init.Data.Repr", + "Init.Data.Option.Basic" + ] + }, + { + "module": "Init.Util", + "root": "lean", + "source_path": "src/lean/Init/Util.lean", + "source_sha256": "687b830b742cc6f55652b53794abccc8c13e96ab61156519879e37daee3be985", + "object_path": "lib/lean/Init/Util.olean", + "object_sha256": "90c6d528600b1c7c9bf61248955304c54da741ac0fc8ffe74687daae50f9cd1d", + "object_bytes": 91512, + "imports": [ + "Init.Data.String.Basic", + "Init.Data.ToString.Basic" + ] + }, + { + "module": "Init.GetElem", + "root": "lean", + "source_path": "src/lean/Init/GetElem.lean", + "source_sha256": "3d263982a37295a0ebab7f58994d517d35b5b4b03458ed5ab6039e8b7f81c010", + "object_path": "lib/lean/Init/GetElem.olean", + "object_sha256": "4f42261e79f09adf9675daf6bf06d2fb1b73ef38a3aacdefa258d7b742721f33", + "object_bytes": 550248, + "imports": [ + "Init.Util" + ] + }, + { + "module": "Init.Data.List.ToArrayImpl", + "root": "lean", + "source_path": "src/lean/Init/Data/List/ToArrayImpl.lean", + "source_sha256": "6cbc421e5e8b14877f56832c8bee03dca93cbd8e21e467811e226fb98520a1e9", + "object_path": "lib/lean/Init/Data/List/ToArrayImpl.olean", + "object_sha256": "b16a7f1e2ede99353d17033971df80a9b974ff176d9fe50e91ddfce75254354a", + "object_bytes": 33584, + "imports": [ + "Init.Data.List.Basic" + ] + }, + { + "module": "Init.Data.Array.Set", + "root": "lean", + "source_path": "src/lean/Init/Data/Array/Set.lean", + "source_sha256": "cd7b51d7441212c0ea97d0319564d8fd317b408287cf56254b3db82e596c3e83", + "object_path": "lib/lean/Init/Data/Array/Set.olean", + "object_sha256": "4eabade5822cab8fb839d27d8d3aa52a0731a6f54bc80281722e451f03a9519a", + "object_bytes": 52360, + "imports": [ + "Init.Tactics" + ] + }, + { + "module": "Init.Data.Array.Basic", + "root": "lean", + "source_path": "src/lean/Init/Data/Array/Basic.lean", + "source_sha256": "d7dc4cf41f9ca107d178c4fa3885900f6f232c4e7c62fa1feaa50b22edd119b6", + "object_path": "lib/lean/Init/Data/Array/Basic.olean", + "object_sha256": "3ce5207ab3d6ed4f189100c32c1e5f45374b2bef0856604582b10e2521f92250", + "object_bytes": 1651608, + "imports": [ + "Init.WFTactics", + "Init.Data.Nat.Basic", + "Init.Data.Fin.Basic", + "Init.Data.UInt.BasicAux", + "Init.Data.Repr", + "Init.Data.ToString.Basic", + "Init.GetElem", + "Init.Data.List.ToArrayImpl", + "Init.Data.Array.Set" + ] + }, + { + "module": "Init.Data.Array.Subarray", + "root": "lean", + "source_path": "src/lean/Init/Data/Array/Subarray.lean", + "source_sha256": "1ef48825d7dc4f339cb002635b781a80fcf2b5669e9162f7a3562bfffaeb6b96", + "object_path": "lib/lean/Init/Data/Array/Subarray.olean", + "object_sha256": "2170eaaeed64558036fb568bcf502488302e30be622edcc4110c92309c5419fd", + "object_bytes": 457952, + "imports": [ + "Init.Data.Array.Basic" + ] + }, + { + "module": "Init.Syntax", + "root": "lean", + "source_path": "src/lean/Init/Syntax.lean", + "source_sha256": "966af49537f62b214d8a7423806515593bbbe0846f65ffd5697646463ee64810", + "object_path": "lib/lean/Init/Syntax.olean", + "object_sha256": "1c9daa707928743b915afe8af43a2898c0ef5a485112a73e87319767577b2693", + "object_bytes": 39800, + "imports": [ + "Init.Data.Array.Set" + ] + }, + { + "module": "Init.Data.Array.GetLit", + "root": "lean", + "source_path": "src/lean/Init/Data/Array/GetLit.lean", + "source_sha256": "6e65f416918ce937dbfe836a5c5cd3f50f92b972048336ad49baed61094f348f", + "object_path": "lib/lean/Init/Data/Array/GetLit.olean", + "object_sha256": "6b5ab0a48ba94397ecf826e54e7929c020d4997da552fd4b846b819a60e23ab4", + "object_bytes": 100544, + "imports": [ + "Init.Data.Array.Basic" + ] + }, + { + "module": "Init.Data.Option.BasicAux", + "root": "lean", + "source_path": "src/lean/Init/Data/Option/BasicAux.lean", + "source_sha256": "79fdf1897aed0bef92a662289b0a05c021b0a1b2d7a834dae305fa7c155cc733", + "object_path": "lib/lean/Init/Data/Option/BasicAux.olean", + "object_sha256": "3ab17328bcf1a22b93c1bec743ff4ef51f403b91db2810b5196cbbdc58f2fd89", + "object_bytes": 33280, + "imports": [ + "Init.Data.Option.Basic", + "Init.Util" + ] + }, + { + "module": "Init.Meta", + "root": "lean", + "source_path": "src/lean/Init/Meta.lean", + "source_sha256": "bbde7f4160a9d25fa5f58170aacf42e5974c808b1c1becfcc6385ea511ae2ffb", + "object_path": "lib/lean/Init/Meta.olean", + "object_sha256": "74183a64d7652c5832a4daa0b0c1454b70248a2da34c657ad37b98db66b3f3f4", + "object_bytes": 2835264, + "imports": [ + "Init.MetaTypes", + "Init.Syntax", + "Init.Data.Array.GetLit", + "Init.Data.Option.BasicAux" + ] + }, + { + "module": "Init.Conv", + "root": "lean", + "source_path": "src/lean/Init/Conv.lean", + "source_sha256": "93b584500315e31a5a4225a443ada1b07b868cc61038c22a3c27e97dd1f630ab", + "object_path": "lib/lean/Init/Conv.olean", + "object_sha256": "398167c43b1515797e70867df508aec32cc2b2cda40efac1ef35cd4519368173", + "object_bytes": 659400, + "imports": [ + "Init.Tactics", + "Init.Meta" + ] + }, + { + "module": "Init.While", + "root": "lean", + "source_path": "src/lean/Init/While.lean", + "source_sha256": "6f2aa436ae44bcd20f18be3cb3bfdaa29cd13f1e57718593f8b2b841be79180f", + "object_path": "lib/lean/Init/While.olean", + "object_sha256": "81a2def492d8653c5c5da86233380347f9d91d87e93a45267b25ffb5a9ff5aa9", + "object_bytes": 182680, + "imports": [ + "Init.Core" + ] + }, + { + "module": "Init.NotationExtra", + "root": "lean", + "source_path": "src/lean/Init/NotationExtra.lean", + "source_sha256": "45400310b56e1e44d1742a134f02d5f588ee2ec8778746dd796445d5e2b631bf", + "object_path": "lib/lean/Init/NotationExtra.olean", + "object_sha256": "b41df2013830f8c1df8f46738c44f7fb0f7e4c1c547abbf23199b69be5b25ec4", + "object_bytes": 1283056, + "imports": [ + "Init.Data.ToString.Basic", + "Init.Data.Array.Subarray", + "Init.Conv", + "Init.Meta", + "Init.While" + ] + }, + { + "module": "Init.TacticsExtra", + "root": "lean", + "source_path": "src/lean/Init/TacticsExtra.lean", + "source_sha256": "807c38eec79830bb07d70142530f03ee7eeb3c38965d69d09cb31863ec498f6d", + "object_path": "lib/lean/Init/TacticsExtra.olean", + "object_sha256": "7f5ce78408bd373ee943cb54069b4636cabe66a79a60a33cc0d940be71c3ae38", + "object_bytes": 488072, + "imports": [ + "Init.Tactics", + "Init.NotationExtra" + ] + }, + { + "module": "Init.PropLemmas", + "root": "lean", + "source_path": "src/lean/Init/PropLemmas.lean", + "source_sha256": "03a981556c7ad5490a0e29ead921c34b48bc99f6ec6cda43da70aee4ea813bc6", + "object_path": "lib/lean/Init/PropLemmas.olean", + "object_sha256": "2023a046221bd129d5912dc2281a472de181ea3b807c4f94c7a4dd4d103d1541", + "object_bytes": 356992, + "imports": [ + "Init.Core", + "Init.NotationExtra" + ] + }, + { + "module": "Init.Classical", + "root": "lean", + "source_path": "src/lean/Init/Classical.lean", + "source_sha256": "bd10c11d1b0e5786774fc49dd118116dca2537fcd7c1b03067f1f3b2221804dd", + "object_path": "lib/lean/Init/Classical.olean", + "object_sha256": "ce8beaea3c49d220c0bc5801a3a2c68c328a34edf6fb6b5d64942df9e6d36b45", + "object_bytes": 85072, + "imports": [ + "Init.PropLemmas" + ] + }, + { + "module": "Init.ByCases", + "root": "lean", + "source_path": "src/lean/Init/ByCases.lean", + "source_sha256": "d86344762c8cf3d371fd618acee24e48b3400351f3619dbeef041bf11b9177bf", + "object_path": "lib/lean/Init/ByCases.olean", + "object_sha256": "0d101515ce66d1864c59fcbdb0a09c1b251d296aa90f85ab718ed1becbc2a054", + "object_bytes": 115304, + "imports": [ + "Init.Classical" + ] + }, + { + "module": "Init.RCases", + "root": "lean", + "source_path": "src/lean/Init/RCases.lean", + "source_sha256": "4a481778a53ce9867093d6c60712102d816a91e8ff67f1695558c5ca72f32313", + "object_path": "lib/lean/Init/RCases.olean", + "object_sha256": "447ee903caefa1a980545149f93ac8b0159bc6b6924a741ede61bb50b5f8b0cc", + "object_bytes": 145464, + "imports": [ + "Init.Tactics", + "Init.Meta" + ] + }, + { + "module": "Init.Control.EState", + "root": "lean", + "source_path": "src/lean/Init/Control/EState.lean", + "source_sha256": "0c40a6ff0887f8eb319ff26de00bd95214304e4627e3da8c8d377ea3644f8205", + "object_path": "lib/lean/Init/Control/EState.olean", + "object_sha256": "5790e236f7f40273de25a3a4a63debe363cb87c58e8dbb2b8df560b3a9b2edbb", + "object_bytes": 94464, + "imports": [ + "Init.Control.State", + "Init.Control.Except", + "Init.Data.ToString.Basic" + ] + }, + { + "module": "Init.Control.Reader", + "root": "lean", + "source_path": "src/lean/Init/Control/Reader.lean", + "source_sha256": "ebcb8140ed2bfd27083599100f986befed34ae88c7fb65fc2b86392caab3c19e", + "object_path": "lib/lean/Init/Control/Reader.olean", + "object_sha256": "f2bbed55ab6ee4535285db2f51361faa79643745126d97356f17a0e8dc2ac7cf", + "object_bytes": 59392, + "imports": [ + "Init.Control.Basic", + "Init.Control.Id", + "Init.Control.Except" + ] + }, + { + "module": "Init.System.ST", + "root": "lean", + "source_path": "src/lean/Init/System/ST.lean", + "source_sha256": "25efabcc9b15fa542bdd5ee76099f299a09f3b9193d416f23b80d59b669c4a1e", + "object_path": "lib/lean/Init/System/ST.olean", + "object_sha256": "5373ae4954b1aee3cf2f03c73acf8bc0da754b08e47e353e7e1e1ecd095727b5", + "object_bytes": 167208, + "imports": [ + "Init.Classical", + "Init.Control.EState", + "Init.Control.Reader" + ] + }, + { + "module": "Init.Control.StateRef", + "root": "lean", + "source_path": "src/lean/Init/Control/StateRef.lean", + "source_sha256": "f49855afdb16403411f314bdafed7e0fbdc8c97d0957dbd9896a99ddd84ade9c", + "object_path": "lib/lean/Init/Control/StateRef.olean", + "object_sha256": "d3984c8464bccdc7d646d4a06aa5ff4ee6af8224a664ed8e0fc7cb5a25bbeb31", + "object_bytes": 105000, + "imports": [ + "Init.System.ST" + ] + }, + { + "module": "Init.Control.Option", + "root": "lean", + "source_path": "src/lean/Init/Control/Option.lean", + "source_sha256": "2a5b8dd007fd6d1ced8624af0f9ec4e7070e0fdc80d07780dfe0ca9d8df0715d", + "object_path": "lib/lean/Init/Control/Option.olean", + "object_sha256": "a06f739c1607dd0af2c054fee5ecffbc9f9f967f1da099dd596ed8b9ab07457e", + "object_bytes": 154384, + "imports": [ + "Init.Data.Option.Basic", + "Init.Control.Basic", + "Init.Control.Except" + ] + }, + { + "module": "Init.Data.ToString.Macro", + "root": "lean", + "source_path": "src/lean/Init/Data/ToString/Macro.lean", + "source_sha256": "96df22bd174defc064d94b722d0f1bd63734369dea6289ea4ee903d7b290580c", + "object_path": "lib/lean/Init/Data/ToString/Macro.olean", + "object_sha256": "812492a3958c3abdb85050e7a470f30017ad61b4609ed2b35393ccfaef3d1510", + "object_bytes": 63952, + "imports": [ + "Init.Meta", + "Init.Data.ToString.Basic" + ] + }, + { + "module": "Init.Ext", + "root": "lean", + "source_path": "src/lean/Init/Ext.lean", + "source_sha256": "53d128986346ebef5b74a0b9e3a66e43e2cc80d71331a629b34383ca4f02f925", + "object_path": "lib/lean/Init/Ext.olean", + "object_sha256": "5ec70a5c48578a1a2c5a0bb55337277c490f7104c65ad11c43f9b1c42ab6a1ed", + "object_bytes": 163448, + "imports": [ + "Init.Data.ToString.Macro", + "Init.TacticsExtra", + "Init.RCases" + ] + }, + { + "module": "Init.Control.Lawful.Basic", + "root": "lean", + "source_path": "src/lean/Init/Control/Lawful/Basic.lean", + "source_sha256": "81a0b96f797e6ed617c92fdf0fdc0150574fe8d1c727531c7a76cf93825cf753", + "object_path": "lib/lean/Init/Control/Lawful/Basic.olean", + "object_sha256": "8d1fdbee8edac4379126a01928d1682c0276e82d4273feb98becd74e3ee511b3", + "object_bytes": 318296, + "imports": [ + "Init.Ext", + "Init.SimpLemmas", + "Init.Meta" + ] + }, + { + "module": "Init.Control.Lawful.Instances", + "root": "lean", + "source_path": "src/lean/Init/Control/Lawful/Instances.lean", + "source_sha256": "d26e9d8ea47d4aff853dcec0324aa4bcf202fb028a63fbc83759a543288847d0", + "object_path": "lib/lean/Init/Control/Lawful/Instances.olean", + "object_sha256": "9f5967b42cbf1d94a90aa8e3960eedc591830dd3020f34b7ecf8ddaaf0cec828", + "object_bytes": 197432, + "imports": [ + "Init.Control.Lawful.Basic", + "Init.Control.Except", + "Init.Control.State", + "Init.Control.StateRef", + "Init.Ext" + ] + }, + { + "module": "Init.Control.Lawful.Lemmas", + "root": "lean", + "source_path": "src/lean/Init/Control/Lawful/Lemmas.lean", + "source_sha256": "19857d695af7b55b55ae6bde4488cae9580037ee23cde038d33a3c7b71934559", + "object_path": "lib/lean/Init/Control/Lawful/Lemmas.olean", + "object_sha256": "95890edb01c691744a12c8c2b5996bc8cbe3c4403ef6e4676a0f6b14113e198d", + "object_bytes": 32720, + "imports": [ + "Init.Control.Lawful.Basic", + "Init.RCases", + "Init.ByCases" + ] + }, + { + "module": "Init.Control.Lawful.MonadLift.Basic", + "root": "lean", + "source_path": "src/lean/Init/Control/Lawful/MonadLift/Basic.lean", + "source_sha256": "bd8da797465c2b389bab3b557775b63fb1b276b0efea7711196a750f927d41ef", + "object_path": "lib/lean/Init/Control/Lawful/MonadLift/Basic.olean", + "object_sha256": "7d540cf53e4a8b0603de7f8f8f58e4033d3058d777811aa09291acba5ae0b3f9", + "object_bytes": 66256, + "imports": [ + "Init.Control.Basic" + ] + }, + { + "module": "Init.Control.Lawful.MonadLift.Lemmas", + "root": "lean", + "source_path": "src/lean/Init/Control/Lawful/MonadLift/Lemmas.lean", + "source_sha256": "5ae7b28c7219aee57719ab425bc1840483f5dc98e042d708ea14d56ef26f89c4", + "object_path": "lib/lean/Init/Control/Lawful/MonadLift/Lemmas.olean", + "object_sha256": "8f398d18851677118f9647eb3f37889dc31cb985a4cf156e68631ec06ee4785a", + "object_bytes": 45240, + "imports": [ + "Init.Control.Lawful.Basic", + "Init.Control.Lawful.MonadLift.Basic" + ] + }, + { + "module": "Init.Control.ExceptCps", + "root": "lean", + "source_path": "src/lean/Init/Control/ExceptCps.lean", + "source_sha256": "816578d049ac118fcaac2b80b99451c8aaec9dd982ff43ab984ea9b4ec231a04", + "object_path": "lib/lean/Init/Control/ExceptCps.olean", + "object_sha256": "aac4941ade387732ce4a5b64eb2a4d053de2ed650385ab2e0ff4db4e37237501", + "object_bytes": 135120, + "imports": [ + "Init.Control.Lawful.Basic" + ] + }, + { + "module": "Init.Control.StateCps", + "root": "lean", + "source_path": "src/lean/Init/Control/StateCps.lean", + "source_sha256": "afa20b51a1e81fc9d21f61431c41146b04cca0ba64ea0ae32775a4c399540a1a", + "object_path": "lib/lean/Init/Control/StateCps.olean", + "object_sha256": "3288c2eeb533c59da6724176eef8c577a6753ec87edd2d8e65e6f8b2bd32abb3", + "object_bytes": 144360, + "imports": [ + "Init.Control.Lawful.Basic" + ] + }, + { + "module": "Init.Control.Lawful.MonadLift.Instances", + "root": "lean", + "source_path": "src/lean/Init/Control/Lawful/MonadLift/Instances.lean", + "source_sha256": "6b84c5f233a8744d2beb1e78741ce7e5748bb45fb8db22377a3dac434e811380", + "object_path": "lib/lean/Init/Control/Lawful/MonadLift/Instances.olean", + "object_sha256": "c755306f6c1cc2287f261202374340334673b66ff7c769f84ca36db02d461d90", + "object_bytes": 88368, + "imports": [ + "Init.Control.Option", + "Init.Control.Except", + "Init.Control.ExceptCps", + "Init.Control.StateRef", + "Init.Control.StateCps", + "Init.Control.Lawful.MonadLift.Lemmas", + "Init.Control.Lawful.Instances" + ] + }, + { + "module": "Init.Control.Lawful.MonadLift", + "root": "lean", + "source_path": "src/lean/Init/Control/Lawful/MonadLift.lean", + "source_sha256": "6f5a9cde5d3fda40921c42ab2f4ebfb8467fcf21a4d3c6e2ef9f47f2f4a03a17", + "object_path": "lib/lean/Init/Control/Lawful/MonadLift.olean", + "object_sha256": "5bc163e4d5d65d7756f14a1f6d40cdaee26617f672e5f05a1b5477fc7b1f32f2", + "object_bytes": 18328, + "imports": [ + "Init.Control.Lawful.MonadLift.Basic", + "Init.Control.Lawful.MonadLift.Lemmas", + "Init.Control.Lawful.MonadLift.Instances" + ] + }, + { + "module": "Init.Control.Lawful", + "root": "lean", + "source_path": "src/lean/Init/Control/Lawful.lean", + "source_sha256": "16c719ca2d814e7a5e889575109ee568fe62e89ffc45f4cad3a33486baee1482", + "object_path": "lib/lean/Init/Control/Lawful.olean", + "object_sha256": "8d76c6c6e393401f8e786cb24c74ff4a233429acd54d5baac6cdfa142b676476", + "object_bytes": 18360, + "imports": [ + "Init.Control.Lawful.Basic", + "Init.Control.Lawful.Instances", + "Init.Control.Lawful.Lemmas", + "Init.Control.Lawful.MonadLift" + ] + }, + { + "module": "Init.Control", + "root": "lean", + "source_path": "src/lean/Init/Control.lean", + "source_sha256": "e3fe6af4b02ed220efd199ad3a0d0d6ee6556dbd43d79ed93b19236e72d281f4", + "object_path": "lib/lean/Init/Control.olean", + "object_sha256": "4f34719c40978bb6e67fa56878e52a6fba94e61dc9a4c5b68bdd7d965e8b534e", + "object_bytes": 18920, + "imports": [ + "Init.Control.Basic", + "Init.Control.State", + "Init.Control.StateRef", + "Init.Control.Id", + "Init.Control.Except", + "Init.Control.Reader", + "Init.Control.Option", + "Init.Control.Lawful", + "Init.Control.StateCps", + "Init.Control.ExceptCps" + ] + }, + { + "module": "Init.Data.Bool", + "root": "lean", + "source_path": "src/lean/Init/Data/Bool.lean", + "source_sha256": "f418d6d98e4a2a8618027662eafdcf8abb69120e307254d309328e9afa1e3af9", + "object_path": "lib/lean/Init/Data/Bool.olean", + "object_sha256": "0837e830138f3bd7189834aacd282d05074ee56f85e00317842298706e4af08e", + "object_bytes": 285248, + "imports": [ + "Init.NotationExtra" + ] + }, + { + "module": "Init.Data.Int.Lemmas", + "root": "lean", + "source_path": "src/lean/Init/Data/Int/Lemmas.lean", + "source_sha256": "495dc4a2607d213fbcfce486d4a6e9fa42eb2d4be7ad6c92503118aa5be7594d", + "object_path": "lib/lean/Init/Data/Int/Lemmas.olean", + "object_sha256": "7cb0b5be143d98e78970799e3d96b1e7a4da8a79218a826c0c1bf0abc9853569", + "object_bytes": 190704, + "imports": [ + "Init.Conv", + "Init.NotationExtra", + "Init.PropLemmas" + ] + }, + { + "module": "Init.Data.Nat.MinMax", + "root": "lean", + "source_path": "src/lean/Init/Data/Nat/MinMax.lean", + "source_sha256": "fc187a97b5850c6a72113df892d061c67b734351dcbc656c00242158b677d8b9", + "object_path": "lib/lean/Init/Data/Nat/MinMax.olean", + "object_sha256": "c08dcc5153a9bc3bb86012b3bf15fd3d8f3bf5504640666b513c2e94fbfeca00", + "object_bytes": 58576, + "imports": [ + "Init.ByCases" + ] + }, + { + "module": "Init.Data.Prod", + "root": "lean", + "source_path": "src/lean/Init/Data/Prod.lean", + "source_sha256": "9b6238c1e2f2b8a48c79275117fc9ddb718d9f32b278e605da17f4d3c8167db5", + "object_path": "lib/lean/Init/Data/Prod.olean", + "object_sha256": "99aae4614bc0e4606239804d63846a89b0c4179fe48d42a9538fd03b76cbd4f6", + "object_bytes": 67424, + "imports": [ + "Init.SimpLemmas", + "Init.NotationExtra" + ] + }, + { + "module": "Init.Data.RArray", + "root": "lean", + "source_path": "src/lean/Init/Data/RArray.lean", + "source_sha256": "5a5de8ccd4b6d4a9c027b0c89093f345b680ad6f25595739d2fb56853bebe582", + "object_path": "lib/lean/Init/Data/RArray.olean", + "object_sha256": "f51648c2eb12409dcf505ffb328ba6622e1b3c2ffc3ee065024b7052df5ea389", + "object_bytes": 98104, + "imports": [ + "Init.PropLemmas" + ] + }, + { + "module": "Init.Data.Nat.Linear", + "root": "lean", + "source_path": "src/lean/Init/Data/Nat/Linear.lean", + "source_sha256": "d87b61dde4b955838248d30dc235509d9f0f3c04eedb36189ce8708ef684b279", + "object_path": "lib/lean/Init/Data/Nat/Linear.olean", + "object_sha256": "dd7b1f9f7cce304c81a7528954ae004a0bef4204cffb46991e6aa46f6c7ef505", + "object_bytes": 502896, + "imports": [ + "Init.ByCases", + "Init.Data.Prod", + "Init.Data.RArray" + ] + }, + { + "module": "Init.Data.Nat.Log2", + "root": "lean", + "source_path": "src/lean/Init/Data/Nat/Log2.lean", + "source_sha256": "0c5f44932e1ef2f005f66be4b5d53d58f5b2d066ee9a883814c9a7685110905f", + "object_path": "lib/lean/Init/Data/Nat/Log2.olean", + "object_sha256": "fd989329f1b5b1ef2a7472bad01bc26b013582eeb745a23c2fac46c45e82328f", + "object_bytes": 50544, + "imports": [ + "Init.Data.Nat.Linear" + ] + }, + { + "module": "Init.Data.Nat.Power2", + "root": "lean", + "source_path": "src/lean/Init/Data/Nat/Power2.lean", + "source_sha256": "0cf3b25848bc578869e4646976eabc8321af401615b0c179fb7ed5094ea6eb3f", + "object_path": "lib/lean/Init/Data/Nat/Power2.olean", + "object_sha256": "0242ea1370b1898dbf81dbc18036fe04ad99f83a2ce7b6c8a334647f620b5819", + "object_bytes": 47032, + "imports": [ + "Init.Data.Nat.Linear" + ] + }, + { + "module": "Init.Data.Int.DivMod.Basic", + "root": "lean", + "source_path": "src/lean/Init/Data/Int/DivMod/Basic.lean", + "source_sha256": "d7d757daba638a58189f17823bed0c3db107f07f1056348b3675bb49c78ef88b", + "object_path": "lib/lean/Init/Data/Int/DivMod/Basic.olean", + "object_sha256": "ea082e2f0437312b3638b71dd1727d05d256e0978fd77d1e35d9c44188b04dc9", + "object_bytes": 164696, + "imports": [ + "Init.Data.Int.Basic" + ] + }, + { + "module": "Init.Data.Int.Order", + "root": "lean", + "source_path": "src/lean/Init/Data/Int/Order.lean", + "source_sha256": "a59ae86d284ccbf37483f36d9bdae50cf5583c3e29cb0388e134291d1257286b", + "object_path": "lib/lean/Init/Data/Int/Order.olean", + "object_sha256": "8b397bd436e63104d461f24b7e4c079eeae924e5844b1d0f77f7d673451857f3", + "object_bytes": 480752, + "imports": [ + "Init.Data.Int.Lemmas", + "Init.ByCases" + ] + }, + { + "module": "Init.Data.Nat.Dvd", + "root": "lean", + "source_path": "src/lean/Init/Data/Nat/Dvd.lean", + "source_sha256": "ba7eb1432994b64ec4edccb265f9eb64b7cc11f42d2f86368d209d15bacf663c", + "object_path": "lib/lean/Init/Data/Nat/Dvd.olean", + "object_sha256": "d93d1000d13b02fc3a7bc5c89924a5cb6950f6164458fd10e7024040f6d41a74", + "object_bytes": 98896, + "imports": [ + "Init.Data.Nat.Div.Basic", + "Init.Meta" + ] + }, + { + "module": "Init.Data.Int.DivMod.Bootstrap", + "root": "lean", + "source_path": "src/lean/Init/Data/Int/DivMod/Bootstrap.lean", + "source_sha256": "dabc7950437fb71381ee33c398838429978d94fc80fbba3bc6e1aec5a46b53bd", + "object_path": "lib/lean/Init/Data/Int/DivMod/Bootstrap.olean", + "object_sha256": "bf8eaebb5dcf24eea40306753cf0e55fb47fcda9a401a1fda3cd1ed3480cb50b", + "object_bytes": 215504, + "imports": [ + "Init.Data.Int.DivMod.Basic", + "Init.Data.Int.Order", + "Init.Data.Nat.Dvd", + "Init.RCases" + ] + }, + { + "module": "Init.Omega.Int", + "root": "lean", + "source_path": "src/lean/Init/Omega/Int.lean", + "source_sha256": "d7649b81693fa2a9bd02c52674321235627cda24b66f35b3827339826e7322e4", + "object_path": "lib/lean/Init/Omega/Int.olean", + "object_sha256": "40cfd366d0fbf0d030281fa2f8d70f623ad33d6c418eea53acc8286da04778ba", + "object_bytes": 87736, + "imports": [ + "Init.Data.Int.DivMod.Bootstrap", + "Init.Data.Int.Order" + ] + }, + { + "module": "Init.Data.Option.Instances", + "root": "lean", + "source_path": "src/lean/Init/Data/Option/Instances.lean", + "source_sha256": "89a9bb4330aaa0c47545c7e682a1a97e9778b2cfce68b5e58e04582d20255874", + "object_path": "lib/lean/Init/Data/Option/Instances.olean", + "object_sha256": "75cbe8e43a7063c6a8926328eba08408e333bca953478b532220f7bd182bc341", + "object_bytes": 176880, + "imports": [ + "Init.Data.Option.Basic" + ] + }, + { + "module": "Init.Data.BEq", + "root": "lean", + "source_path": "src/lean/Init/Data/BEq.lean", + "source_sha256": "2f09fb8f63974b97a235125e1133f470039ee6510604cd88718849de02f37df5", + "object_path": "lib/lean/Init/Data/BEq.olean", + "object_sha256": "85eebbec1eedae5f8fd5497837a6ad64b49e70814772e7cd0c8437891f0a12c5", + "object_bytes": 63416, + "imports": [ + "Init.Data.Bool" + ] + }, + { + "module": "Init.Data.Option.Lemmas", + "root": "lean", + "source_path": "src/lean/Init/Data/Option/Lemmas.lean", + "source_sha256": "eb1a24ac91a94ac822db3093e6ef6e58a6b5f4848a15f4be8f96c6e587d96e69", + "object_path": "lib/lean/Init/Data/Option/Lemmas.olean", + "object_sha256": "d8fbde3add7d38946a3a76e00754bc59ed2e3f649744e6591e6afb5e4d55e197", + "object_bytes": 805744, + "imports": [ + "Init.Data.Option.BasicAux", + "Init.Data.Option.Instances", + "Init.Data.BEq", + "Init.Classical", + "Init.Ext" + ] + }, + { + "module": "Init.Data.List.BasicAux", + "root": "lean", + "source_path": "src/lean/Init/Data/List/BasicAux.lean", + "source_sha256": "5574a14bae0601bb3cd22ff5a4a2b30ad3376d57e396fca32fbe56bf3a02ac2c", + "object_path": "lib/lean/Init/Data/List/BasicAux.olean", + "object_sha256": "0e6e0a8c9c2c103004399153e76a1bdb88b524b3a5f5539c3ecdd7d63b9c835d", + "object_bytes": 392376, + "imports": [ + "Init.Data.Nat.Linear" + ] + }, + { + "module": "Init.Data.List.Control", + "root": "lean", + "source_path": "src/lean/Init/Data/List/Control.lean", + "source_sha256": "ee4737ec8e4c9314d3fb49264871e711138e50f826d1d890abdbabdf5256d7d9", + "object_path": "lib/lean/Init/Data/List/Control.olean", + "object_sha256": "50a3fdb431d74b8424abd188b6bde24aec72bb5a8e7c51d808434ab003a80f85", + "object_bytes": 417776, + "imports": [ + "Init.Control.Basic", + "Init.Control.Id", + "Init.Control.Lawful" + ] + }, + { + "module": "Init.BinderPredicates", + "root": "lean", + "source_path": "src/lean/Init/BinderPredicates.lean", + "source_sha256": "6bbe112a658eb467112334eba3ad322e84d61721ff047896e40d8f1e80fe0693", + "object_path": "lib/lean/Init/BinderPredicates.olean", + "object_sha256": "f994d67f495198cc59df5e4c458a9a788b5d31246b4409fc7e5920838d0aa657", + "object_bytes": 241616, + "imports": [ + "Init.NotationExtra" + ] + }, + { + "module": "Init.Data.List.Lemmas", + "root": "lean", + "source_path": "src/lean/Init/Data/List/Lemmas.lean", + "source_sha256": "d8fc731c3950655b66c6354085b34f7405b3b3d1f97bc3a7f4e3a1f5b0175ac0", + "object_path": "lib/lean/Init/Data/List/Lemmas.olean", + "object_sha256": "df96288aad67c21ad262ea274c0432a88ac21bcaa0d5d62d9f09bff0201a2f7f", + "object_bytes": 1836960, + "imports": [ + "Init.Data.Bool", + "Init.Data.Option.Lemmas", + "Init.Data.List.BasicAux", + "Init.Data.List.Control", + "Init.Control.Lawful.Basic", + "Init.BinderPredicates" + ] + }, + { + "module": "Init.Data.List.TakeDrop", + "root": "lean", + "source_path": "src/lean/Init/Data/List/TakeDrop.lean", + "source_sha256": "f96aa008b19859b9525e6e69ca3df971c9f53991ffcd21d08b51c9b0dc1f7c02", + "object_path": "lib/lean/Init/Data/List/TakeDrop.olean", + "object_sha256": "cd87b42ae060f1a1d3fa8067d3749fe2d734ff007401dd9ae7773ab2bb6e338d", + "object_bytes": 210080, + "imports": [ + "Init.Data.List.Basic", + "Init.Data.List.Lemmas" + ] + }, + { + "module": "Init.Data.Function", + "root": "lean", + "source_path": "src/lean/Init/Data/Function.lean", + "source_sha256": "875c7b063db3bc10d4e88a055c855f16d0cbfa5c7f9d2dd305c7248f2e7a7aa6", + "object_path": "lib/lean/Init/Data/Function.olean", + "object_sha256": "1bb34a62723fe4c53e553eb150c817b89b7fe764048918eb873dcfad29535124", + "object_bytes": 37616, + "imports": [ + "Init.Core" + ] + }, + { + "module": "Init.Data.List.Zip", + "root": "lean", + "source_path": "src/lean/Init/Data/List/Zip.lean", + "source_sha256": "3f00961c74a94295d143f134facb42dbde38dc478b0dae75db865e8848df3345", + "object_path": "lib/lean/Init/Data/List/Zip.olean", + "object_sha256": "eb1fceaa3bec463aa45eb7b33bd239886332daf3ad02db6590013be378cbd02f", + "object_bytes": 268728, + "imports": [ + "Init.Data.List.TakeDrop", + "Init.Data.Function" + ] + }, + { + "module": "Init.Data.Nat.Gcd", + "root": "lean", + "source_path": "src/lean/Init/Data/Nat/Gcd.lean", + "source_sha256": "7e8938d6bc0ba06b7850f4f2574b975e69024d22989de3b13afabd594815744f", + "object_path": "lib/lean/Init/Data/Nat/Gcd.olean", + "object_sha256": "a3ff37593dfc575be58d41633fca7c92b00e5c7109e2d77db224403afd3e22de", + "object_bytes": 157816, + "imports": [ + "Init.Data.Nat.Dvd", + "Init.NotationExtra", + "Init.RCases" + ] + }, + { + "module": "Init.Omega.IntList", + "root": "lean", + "source_path": "src/lean/Init/Omega/IntList.lean", + "source_sha256": "42013e27571d6b761e5023c34fe9236b97459bc201719edbe63a59de7380c371", + "object_path": "lib/lean/Init/Omega/IntList.olean", + "object_sha256": "2e0b7f193027dc6beb8d6185b293eee8c87d0329dd5722f43129cd75f1378c18", + "object_bytes": 233640, + "imports": [ + "Init.Data.List.Zip", + "Init.Data.Int.DivMod.Bootstrap", + "Init.Data.Nat.Gcd" + ] + }, + { + "module": "Init.Omega.Coeffs", + "root": "lean", + "source_path": "src/lean/Init/Omega/Coeffs.lean", + "source_sha256": "abb3a8edf4c16e495bd229924ab5b70c71567c70feccd0731cc00ba8337b674c", + "object_path": "lib/lean/Init/Omega/Coeffs.olean", + "object_sha256": "9494949689ad6039ff740b254587174a8af4e01b4f29c9502c72dad563955fcb", + "object_bytes": 77592, + "imports": [ + "Init.Omega.IntList" + ] + }, + { + "module": "Init.Omega.LinearCombo", + "root": "lean", + "source_path": "src/lean/Init/Omega/LinearCombo.lean", + "source_sha256": "cf931aff58ec190aa909404a4bb6351a5061b0c0eab0429a0c73f971b70aff0c", + "object_path": "lib/lean/Init/Omega/LinearCombo.olean", + "object_sha256": "e3c5379a20a8b9427d24c2829d593ec11f05ee01fa6f59c9a8f5b2667b740487", + "object_bytes": 227928, + "imports": [ + "Init.Omega.Coeffs", + "Init.Data.ToString.Macro" + ] + }, + { + "module": "Init.Omega.Constraint", + "root": "lean", + "source_path": "src/lean/Init/Omega/Constraint.lean", + "source_sha256": "d7261993f854a576cd67356114b866e40f9cf1ae5761f9592bef273a78fb634d", + "object_path": "lib/lean/Init/Omega/Constraint.olean", + "object_sha256": "6c73c07aa00fb77fd6aeb372cae3b856e557959154c23258369e03f0413e093e", + "object_bytes": 371056, + "imports": [ + "Init.Omega.LinearCombo", + "Init.Omega.Int" + ] + }, + { + "module": "Init.Omega.Logic", + "root": "lean", + "source_path": "src/lean/Init/Omega/Logic.lean", + "source_sha256": "79582c9bd701ff4d3df309749a170fe6f84bd29c3a5fce361c6b6b9f1c2a683d", + "object_path": "lib/lean/Init/Omega/Logic.olean", + "object_sha256": "58a7ed671ccb315985386de1a3bc76078eebb263b69e9b93292d5bb40958dc34", + "object_bytes": 25072, + "imports": [ + "Init.PropLemmas" + ] + }, + { + "module": "Init.Omega", + "root": "lean", + "source_path": "src/lean/Init/Omega.lean", + "source_sha256": "7095f1c0101ec74a0ac2e191310bb9ed49e93c57318cba07f98619e3132e6276", + "object_path": "lib/lean/Init/Omega.olean", + "object_sha256": "f7af2aea75e5c4815473d7f9f9484d25214190203731d803111387eb50667d7b", + "object_bytes": 18352, + "imports": [ + "Init.Omega.Int", + "Init.Omega.IntList", + "Init.Omega.LinearCombo", + "Init.Omega.Constraint", + "Init.Omega.Logic" + ] + }, + { + "module": "Init.Data.Nat.Mod", + "root": "lean", + "source_path": "src/lean/Init/Data/Nat/Mod.lean", + "source_sha256": "8f5625e26d695cdbc050816320df6d861ee8eb3dae6d77872950747a1d4774bb", + "object_path": "lib/lean/Init/Data/Nat/Mod.olean", + "object_sha256": "dcfcd0251a1a896d6387fadcfff072f0d8d1a3af5ddccf3fa5c01784545b970a", + "object_bytes": 36664, + "imports": [ + "Init.Omega" + ] + }, + { + "module": "Init.Data.Nat.Lemmas", + "root": "lean", + "source_path": "src/lean/Init/Data/Nat/Lemmas.lean", + "source_sha256": "465248e61af01b1005edc6fb2e0849a89be6111bf347381473c2c0e40a4c371f", + "object_path": "lib/lean/Init/Data/Nat/Lemmas.olean", + "object_sha256": "1c1b42eb74f204391a12526f6d2d793af0941b5b017bf7a6fdaebb4622639111", + "object_bytes": 652376, + "imports": [ + "Init.Data.Nat.Bitwise.Basic", + "Init.Data.Nat.MinMax", + "Init.Data.Nat.Log2", + "Init.Data.Nat.Power2", + "Init.Data.Nat.Mod" + ] + }, + { + "module": "Init.Data.Int.Pow", + "root": "lean", + "source_path": "src/lean/Init/Data/Int/Pow.lean", + "source_sha256": "f18f6acb1a038d45dd67cb06008b230203bcda37de769f58fc550931dca80fb0", + "object_path": "lib/lean/Init/Data/Int/Pow.olean", + "object_sha256": "8467f0fca7ac25bdd1d33725ca35e44c581744008fb78c0796ae1068968d47f7", + "object_bytes": 46440, + "imports": [ + "Init.Data.Int.Lemmas", + "Init.Data.Nat.Lemmas" + ] + }, + { + "module": "Init.Data.Nat.Simproc", + "root": "lean", + "source_path": "src/lean/Init/Data/Nat/Simproc.lean", + "source_sha256": "a78b4148d118177771f084edb9b1c52bbfe134b2f1261478dc935d6bfd979ce5", + "object_path": "lib/lean/Init/Data/Nat/Simproc.olean", + "object_sha256": "91f253b5b8e36d73f6139a46921f35ac76d91f18030662d011ccceccbc69984b", + "object_bytes": 39168, + "imports": [ + "Init.Data.Bool", + "Init.Data.Nat.Basic", + "Init.Data.Nat.Lemmas" + ] + }, + { + "module": "Init.Data.Nat.Bitwise.Lemmas", + "root": "lean", + "source_path": "src/lean/Init/Data/Nat/Bitwise/Lemmas.lean", + "source_sha256": "674243e3d181902f06ca6956444bcb8945577d5bf53e7010777b93c234e93ba6", + "object_path": "lib/lean/Init/Data/Nat/Bitwise/Lemmas.olean", + "object_sha256": "6e0ee4125ade96ee8272d34a394dc6372deebd91be5815eff7ca64dfff12e731", + "object_bytes": 194096, + "imports": [ + "Init.Data.Bool", + "Init.Data.Int.Pow", + "Init.Data.Nat.Bitwise.Basic", + "Init.Data.Nat.Lemmas", + "Init.Data.Nat.Simproc", + "Init.TacticsExtra" + ] + }, + { + "module": "Init.Data.Int.Bitwise.Basic", + "root": "lean", + "source_path": "src/lean/Init/Data/Int/Bitwise/Basic.lean", + "source_sha256": "e94769852c3b34a253926dd2b47ad2042b0038bbdce0b19866880b874b923776", + "object_path": "lib/lean/Init/Data/Int/Bitwise/Basic.olean", + "object_sha256": "7e317154f25d5ce3d1b0cf006b7aee5fdeb831910f8f57a228327e7fda521c29", + "object_bytes": 39648, + "imports": [ + "Init.Data.Int.Basic", + "Init.Data.Nat.Bitwise.Basic" + ] + }, + { + "module": "Init.Data.Nat.Div.Lemmas", + "root": "lean", + "source_path": "src/lean/Init/Data/Nat/Div/Lemmas.lean", + "source_sha256": "aa88c1d6bb9c154f25e287706269f938af65a976401d15924c213badb996baa1", + "object_path": "lib/lean/Init/Data/Nat/Div/Lemmas.olean", + "object_sha256": "2f0fc4799ff3bbcfdaa45e095571608f429e581ed2b64676b8396bdd91951d03", + "object_bytes": 63504, + "imports": [ + "Init.Omega", + "Init.Data.Nat.Lemmas", + "Init.Data.Nat.Simproc" + ] + }, + { + "module": "Init.Data.Int.DivMod.Lemmas", + "root": "lean", + "source_path": "src/lean/Init/Data/Int/DivMod/Lemmas.lean", + "source_sha256": "8ed31643a1d40299f2f7bbe3db5e5412270ed08eb9b6917d9a005e4c9cd3ae5a", + "object_path": "lib/lean/Init/Data/Int/DivMod/Lemmas.olean", + "object_sha256": "a37d7a5040f18b717827b6c6b98aa68906009b108cdb04e9221e13acdeb37a9b", + "object_bytes": 1048160, + "imports": [ + "Init.Data.Int.DivMod.Bootstrap", + "Init.Data.Nat.Lemmas", + "Init.Data.Nat.Div.Lemmas", + "Init.Data.Int.Order", + "Init.Data.Int.Lemmas", + "Init.Data.Nat.Dvd", + "Init.RCases" + ] + }, + { + "module": "Init.Data.Int.Bitwise.Lemmas", + "root": "lean", + "source_path": "src/lean/Init/Data/Int/Bitwise/Lemmas.lean", + "source_sha256": "d6b0f8985516c0d674b9342a9cddf900c06edade2d29da8fa18c6b626646998b", + "object_path": "lib/lean/Init/Data/Int/Bitwise/Lemmas.olean", + "object_sha256": "a65cea241ac95e8fafb5b96031bc137954cf293993eb8d69b6a8f2056014e456", + "object_bytes": 51248, + "imports": [ + "Init.Data.Nat.Bitwise.Lemmas", + "Init.Data.Int.Bitwise.Basic", + "Init.Data.Int.DivMod.Lemmas" + ] + }, + { + "module": "Init.Data.Int.Bitwise", + "root": "lean", + "source_path": "src/lean/Init/Data/Int/Bitwise.lean", + "source_sha256": "1fa2291abaea198c893c8cb2c3f256628574e44b4fa52e4d1c675ec8626ad842", + "object_path": "lib/lean/Init/Data/Int/Bitwise.olean", + "object_sha256": "ec2cd361d560837a9171bd2c7dfb03374eb577079fae1d306f636930ca1ef8d7", + "object_bytes": 18208, + "imports": [ + "Init.Data.Int.Bitwise.Basic", + "Init.Data.Int.Bitwise.Lemmas" + ] + }, + { + "module": "Init.Data.BitVec.Basic", + "root": "lean", + "source_path": "src/lean/Init/Data/BitVec/Basic.lean", + "source_sha256": "9369666b12283e8f1c926401fc0a103e03f54ea2fa684c9a23bd8f38a9e846e0", + "object_path": "lib/lean/Init/Data/BitVec/Basic.olean", + "object_sha256": "6af1f0c6914270cb703199b5245cf4e66c6fac69c7cee35780b004366290ea36", + "object_bytes": 479344, + "imports": [ + "Init.Data.Fin.Basic", + "Init.Data.Nat.Bitwise.Lemmas", + "Init.Data.Nat.Power2", + "Init.Data.Int.Bitwise", + "Init.Data.BitVec.BasicAux" + ] + }, + { + "module": "Init.Data.UInt.Basic", + "root": "lean", + "source_path": "src/lean/Init/Data/UInt/Basic.lean", + "source_sha256": "181b5256b4964c76214e71e84492e7328d28248e9550543ef4e27bb0180e287d", + "object_path": "lib/lean/Init/Data/UInt/Basic.olean", + "object_sha256": "1774fc65f26163f2b419050eec571dc51a7e18b359b71514da53e3df557411c9", + "object_bytes": 325984, + "imports": [ + "Init.Data.UInt.BasicAux", + "Init.Data.BitVec.Basic" + ] + }, + { + "module": "Init.Data.Fin.Log2", + "root": "lean", + "source_path": "src/lean/Init/Data/Fin/Log2.lean", + "source_sha256": "5e8b05083ec47d02e933a8df5412edbd06e34bedafca85903c35e69c838201a9", + "object_path": "lib/lean/Init/Data/Fin/Log2.olean", + "object_sha256": "a23ef80aed07b125e53256600f7ee56070335aa50292aa2265c35f78164c8211", + "object_bytes": 23624, + "imports": [ + "Init.Data.Nat.Log2" + ] + }, + { + "module": "Init.Data.UInt.Log2", + "root": "lean", + "source_path": "src/lean/Init/Data/UInt/Log2.lean", + "source_sha256": "cd7a0fb9c62337fbb482a222199b212a310049fd18f102a1924fd56993fd74be", + "object_path": "lib/lean/Init/Data/UInt/Log2.olean", + "object_sha256": "4ba94f3faed7ead839fc04d0ff766119d0ada278d2dee4662be6b87acda51403", + "object_bytes": 25008, + "imports": [ + "Init.Data.Fin.Log2" + ] + }, + { + "module": "Init.Data.Fin.Lemmas", + "root": "lean", + "source_path": "src/lean/Init/Data/Fin/Lemmas.lean", + "source_sha256": "d5eb18d071b906f8fec9cac0c78d653ceed2e0046b7256aaa5fe2cf0dc1f7f8f", + "object_path": "lib/lean/Init/Data/Fin/Lemmas.olean", + "object_sha256": "7d4a71b8a400ee4f64402e804b348131ba93afb10ede1e8d683ae83d7c973f1f", + "object_bytes": 494872, + "imports": [ + "Init.Data.Nat.Lemmas", + "Init.Data.Int.DivMod.Lemmas", + "Init.Ext", + "Init.ByCases", + "Init.Conv", + "Init.Omega" + ] + }, + { + "module": "Init.Data.Nat.Bitwise", + "root": "lean", + "source_path": "src/lean/Init/Data/Nat/Bitwise.lean", + "source_sha256": "a8de99466945d521da465602ec032da5e80bd761360805e8af03093eb9da2641", + "object_path": "lib/lean/Init/Data/Nat/Bitwise.olean", + "object_sha256": "82a0713488dbb223c2ef34e9b12df071f349e7b90b6aaf6cbb9adf84cb176fc0", + "object_bytes": 18208, + "imports": [ + "Init.Data.Nat.Bitwise.Basic", + "Init.Data.Nat.Bitwise.Lemmas" + ] + }, + { + "module": "Init.Data.Fin.Bitwise", + "root": "lean", + "source_path": "src/lean/Init/Data/Fin/Bitwise.lean", + "source_sha256": "7dfd2946f6099507a6e4e004f4f20a97edb0e5f60768a733e5f47a68199e8c7e", + "object_path": "lib/lean/Init/Data/Fin/Bitwise.olean", + "object_sha256": "5267113753adb0f77ddfefb18a57d8dcb0258982e6d9c3a69fc7777f497695ca", + "object_bytes": 45304, + "imports": [ + "Init.Data.Nat.Bitwise", + "Init.Data.Fin.Basic" + ] + }, + { + "module": "Init.Data.Int.LemmasAux", + "root": "lean", + "source_path": "src/lean/Init/Data/Int/LemmasAux.lean", + "source_sha256": "b63f60fa498acdaaea064464840e0f6ef92448d02350a2bd1b3b9630b4533aff", + "object_path": "lib/lean/Init/Data/Int/LemmasAux.olean", + "object_sha256": "56c6a39d03bce12c401f0bec3465a583a13633e226e9794ac4ed680ed9d8a0e2", + "object_bytes": 115024, + "imports": [ + "Init.Data.Int.Order", + "Init.Data.Int.Pow", + "Init.Data.Int.DivMod.Lemmas", + "Init.Omega" + ] + }, + { + "module": "Init.Data.BitVec.Lemmas", + "root": "lean", + "source_path": "src/lean/Init/Data/BitVec/Lemmas.lean", + "source_sha256": "d295aabfc8d328c7985cc068d5068726dee1faa32c42b08ff27c1be64f97f78d", + "object_path": "lib/lean/Init/Data/BitVec/Lemmas.olean", + "object_sha256": "609bea8053577d7c48f9d06dd6de362c79c0506b2e04e1905b4c3bd6b8d69303", + "object_bytes": 1311696, + "imports": [ + "Init.Data.Bool", + "Init.Data.BitVec.Basic", + "Init.Data.BitVec.BasicAux", + "Init.Data.Fin.Lemmas", + "Init.Data.Nat.Lemmas", + "Init.Data.Nat.Div.Lemmas", + "Init.Data.Nat.Mod", + "Init.Data.Nat.Div.Lemmas", + "Init.Data.Int.Bitwise.Lemmas", + "Init.Data.Int.LemmasAux", + "Init.Data.Int.Pow", + "Init.Data.Int.LemmasAux" + ] + }, + { + "module": "Init.Data.Fin.Iterate", + "root": "lean", + "source_path": "src/lean/Init/Data/Fin/Iterate.lean", + "source_sha256": "86a552cc4c5d9864fd481eab176babef577a2aae85a1ef36a8cb2a30e7b04d43", + "object_path": "lib/lean/Init/Data/Fin/Iterate.olean", + "object_sha256": "1cdf8bd217e52e97c8fe9674bbf857a747753a9e6b5372a709046188e0d60892", + "object_bytes": 61568, + "imports": [ + "Init.PropLemmas", + "Init.Data.Fin.Basic" + ] + }, + { + "module": "Init.Data.BitVec.Folds", + "root": "lean", + "source_path": "src/lean/Init/Data/BitVec/Folds.lean", + "source_sha256": "5b623d6608d5517a886a59bd75825bd3661d3b0b51c495cb29b543cdbb962dcd", + "object_path": "lib/lean/Init/Data/BitVec/Folds.olean", + "object_sha256": "c70dafe68eca30b34174f3b5bc87fb47330eacc4cb7efc50b043b2b482308f75", + "object_bytes": 53088, + "imports": [ + "Init.Data.BitVec.Basic", + "Init.Data.BitVec.Lemmas", + "Init.Data.Nat.Lemmas", + "Init.Data.Fin.Iterate" + ] + }, + { + "module": "Init.Data.Int.DivMod", + "root": "lean", + "source_path": "src/lean/Init/Data/Int/DivMod.lean", + "source_sha256": "177d3ef1c274d07800b839999d82fb1948b829360b54b6ddd1d6c00bd908e0bf", + "object_path": "lib/lean/Init/Data/Int/DivMod.olean", + "object_sha256": "51438c0277bbaf3c3f72e38131863e7afcd435544d025af034c3425f8928927e", + "object_bytes": 18320, + "imports": [ + "Init.Data.Int.DivMod.Basic", + "Init.Data.Int.DivMod.Bootstrap", + "Init.Data.Int.DivMod.Lemmas" + ] + }, + { + "module": "Init.Data.BitVec.Bitblast", + "root": "lean", + "source_path": "src/lean/Init/Data/BitVec/Bitblast.lean", + "source_sha256": "8de9a26bf68c8d3ba3f5ed0f33bea5e38dd29e042cd59b8b028f4018dacd32ee", + "object_path": "lib/lean/Init/Data/BitVec/Bitblast.olean", + "object_sha256": "36ad3b7c4074d11de6fe5ad4cb200aab247d7026ffb200976be53b8218e5fe7d", + "object_bytes": 535480, + "imports": [ + "Init.Data.BitVec.Folds", + "Init.Data.Nat.Bitwise.Basic", + "Init.Data.Nat.Mod", + "Init.Data.Int.DivMod", + "Init.Data.Int.LemmasAux", + "Init.Data.BitVec.Lemmas" + ] + }, + { + "module": "Init.System.Platform", + "root": "lean", + "source_path": "src/lean/Init/System/Platform.lean", + "source_sha256": "f27c9c9245595c7fbb9ff4a0a05ba6132d71e1dd1118ae9a32069a7bef895dd4", + "object_path": "lib/lean/Init/System/Platform.olean", + "object_sha256": "91314872d71175a65b2f68b3442294bd86bd16855c169471d2168748e4d11c9e", + "object_bytes": 40352, + "imports": [ + "Init.Data.Nat.Basic", + "Init.Data.String.Basic" + ] + }, + { + "module": "Init.Data.UInt.Lemmas", + "root": "lean", + "source_path": "src/lean/Init/Data/UInt/Lemmas.lean", + "source_sha256": "4caf860f2d068143d8154a8ff721713905707cfdfa545c5b2f502b1613b5d205", + "object_path": "lib/lean/Init/Data/UInt/Lemmas.olean", + "object_sha256": "2971539b967a895784865365fb58863678a134d6f734fef0c21be85666267a2e", + "object_bytes": 2922072, + "imports": [ + "Init.Data.UInt.Basic", + "Init.Data.UInt.BasicAux", + "Init.Data.Fin.Lemmas", + "Init.Data.Fin.Bitwise", + "Init.Data.BitVec.Basic", + "Init.Data.BitVec.BasicAux", + "Init.Data.BitVec.Lemmas", + "Init.Data.BitVec.Bitblast", + "Init.Data.Nat.Div.Lemmas", + "Init.System.Platform" + ] + }, + { + "module": "Init.Data.UInt.Bitwise", + "root": "lean", + "source_path": "src/lean/Init/Data/UInt/Bitwise.lean", + "source_sha256": "cc0b80bde4141d633ad605aaa0a4b0b3886aa8697fe4e3e7ea4f072943b346ef", + "object_path": "lib/lean/Init/Data/UInt/Bitwise.olean", + "object_sha256": "770e32935dfa80e91daf91dd0c15ffebe3291cc91f2ae5f424513a6e6744f044", + "object_bytes": 888952, + "imports": [ + "Init.Data.BitVec.Basic", + "Init.Data.UInt.Basic", + "Init.Data.UInt.Lemmas", + "Init.Data.Fin.Bitwise" + ] + }, + { + "module": "Init.Data.UInt", + "root": "lean", + "source_path": "src/lean/Init/Data/UInt.lean", + "source_sha256": "aea7de225c1b2998a830ceecaf42e612c44ba3bc68306ce00da002b6b8b9d524", + "object_path": "lib/lean/Init/Data/UInt.olean", + "object_sha256": "fa87718b832cb9a136decc2f3f9706498d4c7d8e8a8c4a9ca5af46ab7c7f6df9", + "object_bytes": 18456, + "imports": [ + "Init.Data.UInt.BasicAux", + "Init.Data.UInt.Basic", + "Init.Data.UInt.Log2", + "Init.Data.UInt.Lemmas", + "Init.Data.UInt.Bitwise" + ] + }, + { + "module": "Init.Data.ByteArray.Basic", + "root": "lean", + "source_path": "src/lean/Init/Data/ByteArray/Basic.lean", + "source_sha256": "9eb934bf5a0a1667cefaf32d15628717398b711929c82e6aad5fc03156b6961d", + "object_path": "lib/lean/Init/Data/ByteArray/Basic.olean", + "object_sha256": "3fddcb8552a30acaa279aeb9bd9c6aeb06e9e9499d3cb3bfb242b3da6310aa13", + "object_bytes": 372136, + "imports": [ + "Init.Data.Array.Basic", + "Init.Data.Array.Subarray", + "Init.Data.UInt.Basic", + "Init.Data.UInt.BasicAux", + "Init.Data.Option.Basic" + ] + }, + { + "module": "Init.Data.String.Extra", + "root": "lean", + "source_path": "src/lean/Init/Data/String/Extra.lean", + "source_sha256": "e38c310a025ffe1053094d552bcdf4cfdad4a8c249b309fc1c947a1fdeade932", + "object_path": "lib/lean/Init/Data/String/Extra.olean", + "object_sha256": "4bd81d0849956838ac652a069b09070e623ae91d482eb9dc7a1edb585a8cd4e7", + "object_bytes": 394976, + "imports": [ + "Init.Data.ByteArray.Basic", + "Init.Data.String.Basic", + "Init.Data.UInt.Lemmas" + ] + }, + { + "module": "Init.Data.Basic", + "root": "lean", + "source_path": "src/lean/Init/Data/Basic.lean", + "source_sha256": "fc33843d547786ef53e02486f94e6506f0a2bbf0cd1a3c3b9918054e44add848", + "object_path": "lib/lean/Init/Data/Basic.olean", + "object_sha256": "92f22ad6603566a47141055d2e23fcff9020005a86fe5c9302486a700313a3b2", + "object_bytes": 19168, + "imports": [ + "Init.Data.Nat.Basic", + "Init.Data.Fin.Basic", + "Init.Data.List.Basic", + "Init.Data.Char.Basic", + "Init.Data.String.Basic", + "Init.Data.Option.Basic", + "Init.Data.UInt", + "Init.Data.Repr", + "Init.Data.ToString.Basic", + "Init.Data.String.Extra" + ] + }, + { + "module": "Init.Data.Nat.Div", + "root": "lean", + "source_path": "src/lean/Init/Data/Nat/Div.lean", + "source_sha256": "24d858308cf455038db9822b58b060e1596d9e21173c22c638c287555cf25a34", + "object_path": "lib/lean/Init/Data/Nat/Div.olean", + "object_sha256": "9f1b3d6203f78fa931d5ccbfa163e849b5fc70c3b47296fbeb65699812e95a54", + "object_bytes": 18208, + "imports": [ + "Init.Data.Nat.Div.Basic", + "Init.Data.Nat.Div.Lemmas" + ] + }, + { + "module": "Init.Data.Nat.Control", + "root": "lean", + "source_path": "src/lean/Init/Data/Nat/Control.lean", + "source_sha256": "575573e8e6de8adc469f24785c098d3f57def49f95adab43e9bcd5a06e98884a", + "object_path": "lib/lean/Init/Data/Nat/Control.olean", + "object_sha256": "f2a797f3a1a4d8c561cca8f7998821b077b3495878b047cec0036c9e3127bd6c", + "object_bytes": 124448, + "imports": [ + "Init.Control.Basic", + "Init.Data.Nat.Basic", + "Init.Omega" + ] + }, + { + "module": "Init.Data.Nat.SOM", + "root": "lean", + "source_path": "src/lean/Init/Data/Nat/SOM.lean", + "source_sha256": "73f16bfa8b5341e7a02130ee8ca99126ccc9272a5cae3d1217cc26e56d4070c7", + "object_path": "lib/lean/Init/Data/Nat/SOM.olean", + "object_sha256": "c73760e6f82fa25d9c10f92724049ff76685dbeef86dad3ca7cc0894ee56b4b5", + "object_bytes": 268096, + "imports": [ + "Init.Data.Nat.Linear", + "Init.Data.List.BasicAux" + ] + }, + { + "module": "Init.Data.Nat.Lcm", + "root": "lean", + "source_path": "src/lean/Init/Data/Nat/Lcm.lean", + "source_sha256": "2689c4d8898111cb2da28b6787a744a29eb8048d52718f5c2e56a912fb9ee945", + "object_path": "lib/lean/Init/Data/Nat/Lcm.olean", + "object_sha256": "fc22bdda15bea5117140b8de688ffc2bf9c3efa7050dc2364088b4fa6de5b039", + "object_bytes": 85480, + "imports": [ + "Init.Data.Nat.Gcd", + "Init.Data.Nat.Lemmas" + ] + }, + { + "module": "Init.Data.SInt.Basic", + "root": "lean", + "source_path": "src/lean/Init/Data/SInt/Basic.lean", + "source_sha256": "a9599c77e9ec2501523b096807d751f08137004cd153a4d4a6881d4e3320a40b", + "object_path": "lib/lean/Init/Data/SInt/Basic.olean", + "object_sha256": "092c9f7ca46e0ba331ffb062863746216b7a8340d88d1627bc8a12a291d881f8", + "object_bytes": 621040, + "imports": [ + "Init.Data.UInt.Basic" + ] + }, + { + "module": "Init.Data.List.Sublist", + "root": "lean", + "source_path": "src/lean/Init/Data/List/Sublist.lean", + "source_sha256": "4e2377f31018764040cf8f6552e589ad67a5b210493364b6dcd520e26560947e", + "object_path": "lib/lean/Init/Data/List/Sublist.olean", + "object_sha256": "11636ad7c72c0ffc6645494817fa8a8538431b6d44fa165b2980ba2d432ba407", + "object_bytes": 1002544, + "imports": [ + "Init.Data.List.TakeDrop" + ] + }, + { + "module": "Init.Data.List.Count", + "root": "lean", + "source_path": "src/lean/Init/Data/List/Count.lean", + "source_sha256": "0eed9405652aa2a6fd95d5c4b3ae69b1025b5211ab68c3d67ab7f11cb634d3d9", + "object_path": "lib/lean/Init/Data/List/Count.olean", + "object_sha256": "9178a354217ee9480f4eab3c2eaa2b7f451ec4f39f3ac3f1ddbb3d15c9984849", + "object_bytes": 161600, + "imports": [ + "Init.Data.List.Sublist" + ] + }, + { + "module": "Init.Data.Subtype", + "root": "lean", + "source_path": "src/lean/Init/Data/Subtype.lean", + "source_sha256": "a5ff9c769e60a288d248e6052ac3e8d14667d1fb637b7ffbb067fc4a9fbf3a4a", + "object_path": "lib/lean/Init/Data/Subtype.olean", + "object_sha256": "bb8586549e3105b60bb117ba7d7c4cdd975349631bac65b9be14fcc0545982c8", + "object_bytes": 50744, + "imports": [ + "Init.Ext", + "Init.Core" + ] + }, + { + "module": "Init.Data.List.Attach", + "root": "lean", + "source_path": "src/lean/Init/Data/List/Attach.lean", + "source_sha256": "7e563d94f47ae8bd687dec6fedd5c5dbf92b28c704bd05666420fe6cf9962235", + "object_path": "lib/lean/Init/Data/List/Attach.olean", + "object_sha256": "589a63e59442c37d5ea6e99dacd0e1013eea88e65336e783e85ce7479dd81494", + "object_bytes": 388840, + "imports": [ + "Init.Data.List.Lemmas", + "Init.Data.List.Count", + "Init.Data.Subtype", + "Init.BinderNameHint" + ] + }, + { + "module": "Init.Data.List.Pairwise", + "root": "lean", + "source_path": "src/lean/Init/Data/List/Pairwise.lean", + "source_sha256": "d4f79b5073686cc3e22f97fab03c4ecab234ee2ced81b24d766cd22e9dc7d617", + "object_path": "lib/lean/Init/Data/List/Pairwise.olean", + "object_sha256": "27b743c9b1f49ddd6c89a7aa05c7c685783b5cb2236e10f192998504a07a8a28", + "object_bytes": 314560, + "imports": [ + "Init.Data.List.Sublist", + "Init.Data.List.Attach" + ] + }, + { + "module": "Init.Data.List.Range", + "root": "lean", + "source_path": "src/lean/Init/Data/List/Range.lean", + "source_sha256": "4954c7b1f6209e46b1398bdadeb3649280cad3f71c2bbfa2bc81996239ed5e22", + "object_path": "lib/lean/Init/Data/List/Range.olean", + "object_sha256": "98e39151b2647409f13b8a713d3614d9b6a81965590ec07dff5d4e151a1f02de", + "object_bytes": 172016, + "imports": [ + "Init.Data.List.Pairwise", + "Init.Data.List.Zip" + ] + }, + { + "module": "Init.Data.Array.Bootstrap", + "root": "lean", + "source_path": "src/lean/Init/Data/Array/Bootstrap.lean", + "source_sha256": "d9c35746175a9ab5b23032313ad74af859455ee375e2f68b02eb332f03c37e05", + "object_path": "lib/lean/Init/Data/Array/Bootstrap.olean", + "object_sha256": "18bf5eed019133db070e66b4c0b83ed857f8b5e93f6c72604c95eb262e5a3ff4", + "object_bytes": 179736, + "imports": [ + "Init.Data.List.TakeDrop", + "Init.Data.Array.Basic" + ] + }, + { + "module": "Init.Data.List.Impl", + "root": "lean", + "source_path": "src/lean/Init/Data/List/Impl.lean", + "source_sha256": "b13def6551f8855059cfe8a9037978b363850f91a2f9622725f7abc6821b77af", + "object_path": "lib/lean/Init/Data/List/Impl.olean", + "object_sha256": "c86f6168c48935a41461b26136b30c84614b4f59090236d8d77292156a40d9ac", + "object_bytes": 613232, + "imports": [ + "Init.Data.Array.Bootstrap" + ] + }, + { + "module": "Init.Data.List.Find", + "root": "lean", + "source_path": "src/lean/Init/Data/List/Find.lean", + "source_sha256": "0a66504300917b5c5a18a424a617477a84c1f1972451fe5a43301d3131f1abe9", + "object_path": "lib/lean/Init/Data/List/Find.olean", + "object_sha256": "6bc61e2b8caf7216d10e438b568b62ae2bc03b5975c61553d99e042dc4d455ee", + "object_bytes": 461168, + "imports": [ + "Init.Data.List.Lemmas", + "Init.Data.List.Sublist", + "Init.Data.List.Range", + "Init.Data.List.Impl", + "Init.Data.List.Attach", + "Init.Data.Fin.Lemmas" + ] + }, + { + "module": "Init.Data.List.Nat.TakeDrop", + "root": "lean", + "source_path": "src/lean/Init/Data/List/Nat/TakeDrop.lean", + "source_sha256": "6eb5d56471d9250dd0fe9e2b0befd309ca2aac49deb021d05aefdff061ce02a1", + "object_path": "lib/lean/Init/Data/List/Nat/TakeDrop.olean", + "object_sha256": "0a2d94dc9ca1206f07ac443dcb0db72a00b7a51d2529cddf0396a81b74c0a55f", + "object_bytes": 216128, + "imports": [ + "Init.Data.List.Zip", + "Init.Data.List.Sublist", + "Init.Data.List.Find", + "Init.Data.Nat.Lemmas" + ] + }, + { + "module": "Init.Data.List.Erase", + "root": "lean", + "source_path": "src/lean/Init/Data/List/Erase.lean", + "source_sha256": "303278cd34217f8201245eac0c52c4ae2fb08479cc0cab48bf30983940e10c70", + "object_path": "lib/lean/Init/Data/List/Erase.olean", + "object_sha256": "2ae7ee72a086f9bee59d4b2f095d140e7dc1ab92c8b3a02d7cc9565cea32b59b", + "object_bytes": 419528, + "imports": [ + "Init.Data.List.Pairwise", + "Init.Data.List.Find" + ] + }, + { + "module": "Init.Data.List.Nat.Erase", + "root": "lean", + "source_path": "src/lean/Init/Data/List/Nat/Erase.lean", + "source_sha256": "d2cecff51e17d7c2d3bb80ce8b189c6ca7329271940ab90ba1e6c3e95b3092de", + "object_path": "lib/lean/Init/Data/List/Nat/Erase.olean", + "object_sha256": "8d738e96fce1017325a5d1801ffe123b054a9b730ea72d3adb7c4ab1a8e0579d", + "object_bytes": 67360, + "imports": [ + "Init.Data.List.Nat.TakeDrop", + "Init.Data.List.Erase" + ] + }, + { + "module": "Init.Data.List.Nat.Modify", + "root": "lean", + "source_path": "src/lean/Init/Data/List/Nat/Modify.lean", + "source_sha256": "e80e9210d080bdddc66c600972d56d72082690f14c9e8c22f31f43dd0e5b3cdf", + "object_path": "lib/lean/Init/Data/List/Nat/Modify.olean", + "object_sha256": "33361984f396c98c03349ed245b588e83af60d6e529b86ea584a0075c190a5ce", + "object_bytes": 175456, + "imports": [ + "Init.Data.List.Nat.TakeDrop", + "Init.Data.List.Nat.Erase" + ] + }, + { + "module": "Init.Data.List.MinMax", + "root": "lean", + "source_path": "src/lean/Init/Data/List/MinMax.lean", + "source_sha256": "12677a679d3a34903290d22c35cf0b95998fc26329231edc9437548a6f3d2bac", + "object_path": "lib/lean/Init/Data/List/MinMax.olean", + "object_sha256": "302ce8584b45f35645ee41ffbb92436faa3b8674be9edf02c2494600228afe3d", + "object_bytes": 157568, + "imports": [ + "Init.Data.List.Lemmas", + "Init.Data.List.Pairwise" + ] + }, + { + "module": "Init.Data.List.Nat.Basic", + "root": "lean", + "source_path": "src/lean/Init/Data/List/Nat/Basic.lean", + "source_sha256": "3cace9385f6429c3f55bcb0b84ec499dc15a7a029f3e9d688d5465af31d352c1", + "object_path": "lib/lean/Init/Data/List/Nat/Basic.olean", + "object_sha256": "4652b23157100185a885ad76b24610b7eadf87df6094c09eb1ec088830803bfa", + "object_bytes": 171176, + "imports": [ + "Init.Data.List.Count", + "Init.Data.List.Find", + "Init.Data.List.MinMax", + "Init.Data.Nat.Lemmas" + ] + }, + { + "module": "Init.Data.Fin.Fold", + "root": "lean", + "source_path": "src/lean/Init/Data/Fin/Fold.lean", + "source_sha256": "cc0336a3f3779441be69f05ef1adfc0a378b2c0ba2b8510ff4fedd1f6b110ca3", + "object_path": "lib/lean/Init/Data/Fin/Fold.olean", + "object_sha256": "148f8f2dcd9b7d8d1382d0bf686cb79d135e57f1b510f1c2a6ae05116733ae1a", + "object_bytes": 184608, + "imports": [ + "Init.Data.Nat.Linear", + "Init.Control.Lawful.Basic", + "Init.Data.Fin.Lemmas" + ] + }, + { + "module": "Init.Data.List.OfFn", + "root": "lean", + "source_path": "src/lean/Init/Data/List/OfFn.lean", + "source_sha256": "4882e3289610841198cfa1902487d679cb91389b39accaf06205e8edc0a0a4d6", + "object_path": "lib/lean/Init/Data/List/OfFn.olean", + "object_sha256": "08f5e99114e32507f92656fdb8cda3f197ddb0f157b3348941f74021006dfc5b", + "object_bytes": 94640, + "imports": [ + "Init.Data.List.Basic", + "Init.Data.Fin.Fold" + ] + }, + { + "module": "Init.Data.List.Monadic", + "root": "lean", + "source_path": "src/lean/Init/Data/List/Monadic.lean", + "source_sha256": "4481d976c71fc24087c33cab70c0686419014137b13df8c9edefcbe91e1f9cc3", + "object_path": "lib/lean/Init/Data/List/Monadic.olean", + "object_sha256": "e4dde44f14eae3f1a21c371a82a858897a988848f1bccabb19c820b54398e669", + "object_bytes": 397384, + "imports": [ + "Init.Data.List.TakeDrop", + "Init.Data.List.Attach", + "Init.Data.List.OfFn", + "Init.Data.Array.Bootstrap", + "Init.Data.List.Control" + ] + }, + { + "module": "Init.Data.Array.Mem", + "root": "lean", + "source_path": "src/lean/Init/Data/Array/Mem.lean", + "source_sha256": "faf3382be8a9124b5e674ab7c8c1fcf0ae07ccb434e9f8de6c8d7f5fe57ee035", + "object_path": "lib/lean/Init/Data/Array/Mem.olean", + "object_sha256": "8464d1a40cb258581148213b46b6d51ba278784808d559d11463dd6cbb997903", + "object_bytes": 195288, + "imports": [ + "Init.Data.Array.Basic", + "Init.Data.Nat.Linear", + "Init.Data.List.BasicAux" + ] + }, + { + "module": "Init.Data.List.Nat.BEq", + "root": "lean", + "source_path": "src/lean/Init/Data/List/Nat/BEq.lean", + "source_sha256": "901d8decd318ddca37cd7b4efc654865e3d1a2797e0385cd0ec1646a3f7c0524", + "object_path": "lib/lean/Init/Data/List/Nat/BEq.olean", + "object_sha256": "4dd88c19af4263e8d7c6c8ae8be7dbc5b871e7dc38bb2581eacb9566e638b6d6", + "object_bytes": 37240, + "imports": [ + "Init.Data.Nat.Lemmas", + "Init.Data.List.Basic" + ] + }, + { + "module": "Init.Data.Array.DecidableEq", + "root": "lean", + "source_path": "src/lean/Init/Data/Array/DecidableEq.lean", + "source_sha256": "bb84a83b5d1cb963aa05901d358b5fa201045b6e9da38a1e8f80df20cedf8ccb", + "object_path": "lib/lean/Init/Data/Array/DecidableEq.olean", + "object_sha256": "3d60643891ad8c02b98af93a14988da7dd40e0955c26886705e7dc775c3595ae", + "object_bytes": 104408, + "imports": [ + "Init.Data.Array.Basic", + "Init.Data.BEq", + "Init.Data.List.Nat.BEq", + "Init.ByCases" + ] + }, + { + "module": "Init.Data.Range.Basic", + "root": "lean", + "source_path": "src/lean/Init/Data/Range/Basic.lean", + "source_sha256": "e7f7d80892e0b1d118d939eb90e86f4a3593be3ca53a3546759553de07804389", + "object_path": "lib/lean/Init/Data/Range/Basic.olean", + "object_sha256": "43e4cb8361869bcc19bbd9bdd3bbf898d9c851133522099acd05499a2673d4f7", + "object_bytes": 375352, + "imports": [ + "Init.Meta", + "Init.Omega" + ] + }, + { + "module": "Init.Data.Range.Lemmas", + "root": "lean", + "source_path": "src/lean/Init/Data/Range/Lemmas.lean", + "source_sha256": "ddc105b433f1e113121c7d95d1322a8391249fed0cf7569621f1e922ae5d8653", + "object_path": "lib/lean/Init/Data/Range/Lemmas.olean", + "object_sha256": "f6ff888690125055b494f3d8bac6763e0e1519fabae25ce1effce4409befde23", + "object_bytes": 75352, + "imports": [ + "Init.Data.Range.Basic", + "Init.Data.List.Range", + "Init.Data.List.Monadic", + "Init.Data.Nat.Div.Lemmas" + ] + }, + { + "module": "Init.Data.Range", + "root": "lean", + "source_path": "src/lean/Init/Data/Range.lean", + "source_sha256": "5365dcbe814ab5b27ad2c6ce8f9a4cce155374a47969e97dd461e2aed5e9972d", + "object_path": "lib/lean/Init/Data/Range.olean", + "object_sha256": "db8275c64914015e61c1f9d360df25a6cb2cbc7a292df0be09a0508ca8770c9a", + "object_bytes": 18136, + "imports": [ + "Init.Data.Range.Basic", + "Init.Data.Range.Lemmas" + ] + }, + { + "module": "Init.Data.Array.Lex.Basic", + "root": "lean", + "source_path": "src/lean/Init/Data/Array/Lex/Basic.lean", + "source_sha256": "727579e1675e9fbcad33bbe2e6fdb69fd28fdfb15aa7237b42af1c46c0941a08", + "object_path": "lib/lean/Init/Data/Array/Lex/Basic.olean", + "object_sha256": "2468001809617b6c4acb37657fb91a9838a1afaa878ffedc00f9fd5310c66472", + "object_bytes": 109392, + "imports": [ + "Init.Data.Array.Basic", + "Init.Data.Nat.Lemmas", + "Init.Data.Range" + ] + }, + { + "module": "Init.Data.List.Nat.InsertIdx", + "root": "lean", + "source_path": "src/lean/Init/Data/List/Nat/InsertIdx.lean", + "source_sha256": "efe6030717b06afa4ab31656ea2a8358fd91f346e27f10dc7c5d16ba59bd6703", + "object_path": "lib/lean/Init/Data/List/Nat/InsertIdx.olean", + "object_sha256": "e6bf9ce24e4561834781f432a45ca2b92e6ecc6f2cdda3e28d8dad0c9d01eb0a", + "object_bytes": 140808, + "imports": [ + "Init.Data.List.Nat.Modify" + ] + }, + { + "module": "Init.Data.List.ToArray", + "root": "lean", + "source_path": "src/lean/Init/Data/List/ToArray.lean", + "source_sha256": "8820c249437a68547600a6f82aa78cb436116bca7b49a51c1de73012ac3fc7b9", + "object_path": "lib/lean/Init/Data/List/ToArray.olean", + "object_sha256": "2436e348449def0ae06b86d39d27107c46b6da945f063c939056b4ac3b3acb2b", + "object_bytes": 371680, + "imports": [ + "Init.Data.List.Control", + "Init.Data.List.Impl", + "Init.Data.List.Nat.Erase", + "Init.Data.List.Monadic", + "Init.Data.List.Nat.InsertIdx", + "Init.Data.Array.Lex.Basic", + "Init.Data.Array.Basic", + "Init.Data.Array.Set" + ] + }, + { + "module": "Init.Data.Array.Lemmas", + "root": "lean", + "source_path": "src/lean/Init/Data/Array/Lemmas.lean", + "source_sha256": "7a7da52ce8a2005b2c658ef5d867d4ef633b1becb11a49d13ec2302fb91d1f3b", + "object_path": "lib/lean/Init/Data/Array/Lemmas.olean", + "object_sha256": "a5c54251377944f5f5126135b79974aaa5b8a678476f734906fba84f3708a7bf", + "object_bytes": 1596000, + "imports": [ + "Init.Data.Nat.Lemmas", + "Init.Data.List.Range", + "Init.Data.List.Control", + "Init.Data.List.Nat.TakeDrop", + "Init.Data.List.Nat.Modify", + "Init.Data.List.Nat.Basic", + "Init.Data.List.Monadic", + "Init.Data.List.OfFn", + "Init.Data.Array.Bootstrap", + "Init.Data.Array.Mem", + "Init.Data.Array.DecidableEq", + "Init.Data.Array.Lex.Basic", + "Init.Data.Range.Lemmas", + "Init.TacticsExtra", + "Init.Data.List.ToArray" + ] + }, + { + "module": "Init.Data.List.Nat.Count", + "root": "lean", + "source_path": "src/lean/Init/Data/List/Nat/Count.lean", + "source_sha256": "d4de97a87c1ecaf9c90c91f256213e8b32ccee9c778e1bbf8323b43496b9c258", + "object_path": "lib/lean/Init/Data/List/Nat/Count.olean", + "object_sha256": "b399354be9e9e7b96d3b6bb6555dc35135f61fac8f2c72aa1651211c71d0a8e8", + "object_bytes": 132904, + "imports": [ + "Init.Data.List.Count", + "Init.Data.Nat.Lemmas" + ] + }, + { + "module": "Init.Data.Array.Count", + "root": "lean", + "source_path": "src/lean/Init/Data/Array/Count.lean", + "source_sha256": "5711ed11a900bd202a937d862a32fa0999c13904db18d23e96f0cec89dcef1f0", + "object_path": "lib/lean/Init/Data/Array/Count.olean", + "object_sha256": "0a3e675f1fcc3896f329cd3f1cad5185385bd877d7ca5d4a41f64bcff213bb26", + "object_bytes": 117568, + "imports": [ + "Init.Data.Array.Basic", + "Init.Data.Array.Lemmas", + "Init.Data.List.Nat.Count" + ] + }, + { + "module": "Init.Data.Array.Attach", + "root": "lean", + "source_path": "src/lean/Init/Data/Array/Attach.lean", + "source_sha256": "f3910a1417c5531fa9cfec1af61c8641788cf95a61486118c7e82edaab62b493", + "object_path": "lib/lean/Init/Data/Array/Attach.olean", + "object_sha256": "328290f6a592c7d376e6974d2e666e428e80b734a4619aceafcceef60ec42c53", + "object_bytes": 356320, + "imports": [ + "Init.Data.Array.Mem", + "Init.Data.Array.Lemmas", + "Init.Data.Array.Count", + "Init.Data.List.Attach" + ] + }, + { + "module": "Init.Data.Array.Monadic", + "root": "lean", + "source_path": "src/lean/Init/Data/Array/Monadic.lean", + "source_sha256": "b1e989665f8c58d6e60c2662b50211c15b8f07c040bb199b37bcb00d10846f89", + "object_path": "lib/lean/Init/Data/Array/Monadic.olean", + "object_sha256": "b771a01f750d960175a1eeaaa1fed41895ebb3caa0f2e1f584bb5e78ccc22a18", + "object_bytes": 235432, + "imports": [ + "Init.Data.List.Control", + "Init.Data.Array.Basic", + "Init.Data.Array.Lemmas", + "Init.Data.Array.Attach", + "Init.Data.List.Monadic" + ] + }, + { + "module": "Init.Data.List.FinRange", + "root": "lean", + "source_path": "src/lean/Init/Data/List/FinRange.lean", + "source_sha256": "4a4d27633f36a70ca17e1101ec780c187612c4a839de5e697abd85afe995a12c", + "object_path": "lib/lean/Init/Data/List/FinRange.olean", + "object_sha256": "130c9779bd3360560c0384a76a0893d5dc9e48b9534cce2d9c4cb14e91ce6942", + "object_bytes": 43464, + "imports": [ + "Init.Data.List.OfFn", + "Init.Data.List.Monadic" + ] + }, + { + "module": "Init.Data.Array.OfFn", + "root": "lean", + "source_path": "src/lean/Init/Data/Array/OfFn.lean", + "source_sha256": "95af89161a34e7c9fd60927af88cbd93ef7d0cad7f6103aaff87dca7920304a4", + "object_path": "lib/lean/Init/Data/Array/OfFn.olean", + "object_sha256": "0287f76aaba8f8d23a90819c958befd627627f0789ca60c156c4a38714ae0a6a", + "object_bytes": 89072, + "imports": [ + "Init.Data.Array.Basic", + "Init.Data.Array.Lemmas", + "Init.Data.Array.Monadic", + "Init.Data.List.OfFn", + "Init.Data.List.FinRange" + ] + }, + { + "module": "Init.Data.List.Nat.Range", + "root": "lean", + "source_path": "src/lean/Init/Data/List/Nat/Range.lean", + "source_sha256": "51b2385b7b639991a03fde0b5fadde4b5b1bb72577a2000126e13f93e73bab41", + "object_path": "lib/lean/Init/Data/List/Nat/Range.olean", + "object_sha256": "531013b6b0f96e704775d5d516e9de4db41557cf68e40165a8a3d09cf0799cc4", + "object_bytes": 242720, + "imports": [ + "Init.Data.List.Nat.TakeDrop", + "Init.Data.List.Range", + "Init.Data.List.Pairwise", + "Init.Data.List.Find", + "Init.Data.List.Erase" + ] + }, + { + "module": "Init.Data.Option.List", + "root": "lean", + "source_path": "src/lean/Init/Data/Option/List.lean", + "source_sha256": "58154508af18a2998bd3d1d551315af9718236fcf67bfb449639817bb24316db", + "object_path": "lib/lean/Init/Data/Option/List.olean", + "object_sha256": "c46b40e2fa4b9fa01aac2c5928532aa6679dee1c61233e0ce3b0289815c31ee1", + "object_bytes": 65752, + "imports": [ + "Init.Data.List.Lemmas", + "Init.Data.List.Control", + "Init.Data.Option.Instances" + ] + }, + { + "module": "Init.Data.Option.Array", + "root": "lean", + "source_path": "src/lean/Init/Data/Option/Array.lean", + "source_sha256": "aceb15039a018efb75f57ad329d01704f33a5737b6e56a46d2c79b702d10f7a3", + "object_path": "lib/lean/Init/Data/Option/Array.olean", + "object_sha256": "74f5caaf6138e4e1f4ae37081d21e1f888bc7dae50b22c513b3ab9a44fd9de3a", + "object_bytes": 73096, + "imports": [ + "Init.Data.Array.Lemmas", + "Init.Data.Option.List", + "Init.Data.Option.Instances" + ] + }, + { + "module": "Init.Data.Option.Attach", + "root": "lean", + "source_path": "src/lean/Init/Data/Option/Attach.lean", + "source_sha256": "7299fbcec9eb9ac42739a0e5d57a40f2cacf290e924eb25516601da1824aa0e4", + "object_path": "lib/lean/Init/Data/Option/Attach.olean", + "object_sha256": "30762d1a4d3a7e3398c0e73b30ddaddb2499baf20fda14c77b2331fc7fa8db74", + "object_bytes": 215960, + "imports": [ + "Init.Data.Option.Basic", + "Init.Data.Option.List", + "Init.Data.Option.Array", + "Init.Data.Array.Attach", + "Init.Data.List.Attach", + "Init.BinderPredicates" + ] + }, + { + "module": "Init.Data.List.MapIdx", + "root": "lean", + "source_path": "src/lean/Init/Data/List/MapIdx.lean", + "source_sha256": "daad49c59df4f8dfdbe3c644b8e6bb26198d8a618df864354eac00036a9637e2", + "object_path": "lib/lean/Init/Data/List/MapIdx.olean", + "object_sha256": "a5ce52ea0b7e3d5241fe7a8af0b2bc3aecaeea97700eaa89399f315f1f0be050", + "object_bytes": 369360, + "imports": [ + "Init.Data.Array.Lemmas", + "Init.Data.List.Nat.Range", + "Init.Data.List.OfFn", + "Init.Data.Fin.Lemmas", + "Init.Data.Option.Attach" + ] + }, + { + "module": "Init.Data.Array.MapIdx", + "root": "lean", + "source_path": "src/lean/Init/Data/Array/MapIdx.lean", + "source_sha256": "c4256610e8a6a7454dcc7242f5e66030dd35747382a64080b153e4dd17b411a7", + "object_path": "lib/lean/Init/Data/Array/MapIdx.olean", + "object_sha256": "2142dd24e61d364bed3095e15eb4c1f3e0bfb7bf280f8b37099c775748a8eae5", + "object_bytes": 304728, + "imports": [ + "Init.Data.Array.Basic", + "Init.Data.Array.Lemmas", + "Init.Data.Array.Attach", + "Init.Data.Array.OfFn", + "Init.Data.List.MapIdx" + ] + }, + { + "module": "Init.Data.Array.InsertIdx", + "root": "lean", + "source_path": "src/lean/Init/Data/Array/InsertIdx.lean", + "source_sha256": "f276f8be3982f267dcd532ce542d764855b2500e12c8a25d3f47910e60a2c85f", + "object_path": "lib/lean/Init/Data/Array/InsertIdx.olean", + "object_sha256": "2624b4156e7a6891be05c5c725844928092a35a85c027ef8cac6ab61544d6b58", + "object_bytes": 79424, + "imports": [ + "Init.Data.Array.Lemmas", + "Init.Data.List.Nat.InsertIdx" + ] + }, + { + "module": "Init.Data.Array.TakeDrop", + "root": "lean", + "source_path": "src/lean/Init/Data/Array/TakeDrop.lean", + "source_sha256": "c78482f563d6c910af8a4a06679b732c3f9e30ee952dae4902cb641dc7fd7745", + "object_path": "lib/lean/Init/Data/Array/TakeDrop.olean", + "object_sha256": "a3506f3f2cfd8381673e00f18b99ade1127b8a015168fd3938fa7cac03d7fc0e", + "object_bytes": 29384, + "imports": [ + "Init.Data.Array.Basic", + "Init.Data.Array.Lemmas", + "Init.Data.List.Nat.TakeDrop" + ] + }, + { + "module": "Init.Data.Array.Zip", + "root": "lean", + "source_path": "src/lean/Init/Data/Array/Zip.lean", + "source_sha256": "c1769c30c26e9489d5931e28be6c3b6285159efca757a5b03b4dfc7d4cdec691", + "object_path": "lib/lean/Init/Data/Array/Zip.olean", + "object_sha256": "77b0f115095b0bd89f9cebdeb129d26400d8642099a504c98070ba0727ceff42", + "object_bytes": 208888, + "imports": [ + "Init.Data.Array.Basic", + "Init.Data.Array.TakeDrop", + "Init.Data.List.Zip" + ] + }, + { + "module": "Init.Data.Array.Range", + "root": "lean", + "source_path": "src/lean/Init/Data/Array/Range.lean", + "source_sha256": "93a648a734ac82e35d5c7e6510a2dd36d6b35f5ab3e63ed6f97b4d662d872bf5", + "object_path": "lib/lean/Init/Data/Array/Range.olean", + "object_sha256": "748fab38167a7b6a7825b8d188a94a18f4e54c443ee5e045a359a9a77302bd09", + "object_bytes": 132376, + "imports": [ + "Init.Data.Array.Lemmas", + "Init.Data.Array.Basic", + "Init.Data.Array.OfFn", + "Init.Data.Array.MapIdx", + "Init.Data.Array.Zip", + "Init.Data.List.Nat.Range" + ] + }, + { + "module": "Init.Data.Stream", + "root": "lean", + "source_path": "src/lean/Init/Data/Stream.lean", + "source_sha256": "785f30315f93302437ba69e34f4525179f39d68933dea11321d9ba0212fa94a4", + "object_path": "lib/lean/Init/Data/Stream.olean", + "object_sha256": "3c5a55348429b2a197378f1067d7c654b38de7e08bf16bae88ef27387213f063", + "object_bytes": 168936, + "imports": [ + "Init.Data.Array.Subarray", + "Init.Data.Range" + ] + }, + { + "module": "Init.Data.Vector.Basic", + "root": "lean", + "source_path": "src/lean/Init/Data/Vector/Basic.lean", + "source_sha256": "851834adaeeca6f61af44c9c13f790643ed357cfb71521cca90ffb8cd791b20e", + "object_path": "lib/lean/Init/Data/Vector/Basic.olean", + "object_sha256": "3fb9fcca6e6e4767ef019506f4d02632659a7f411bd1419950643114c17ec8f5", + "object_bytes": 1099968, + "imports": [ + "Init.Data.Array.Lemmas", + "Init.Data.Array.MapIdx", + "Init.Data.Array.InsertIdx", + "Init.Data.Array.Range", + "Init.Data.Range", + "Init.Data.Stream" + ] + }, + { + "module": "Init.Data.Ord", + "root": "lean", + "source_path": "src/lean/Init/Data/Ord.lean", + "source_sha256": "ee3760795a4ce689f075530d151b8dea1f21367e1068b127fdb25a685b0ba8d2", + "object_path": "lib/lean/Init/Data/Ord.olean", + "object_sha256": "2c148ad06edf403dbae50fb321550b7aeb7a4e92b67de8852b27b824f9e1e52c", + "object_bytes": 547192, + "imports": [ + "Init.Data.String.Basic", + "Init.Data.Array.Basic", + "Init.Data.SInt.Basic", + "Init.Data.Vector.Basic" + ] + }, + { + "module": "Init.Data.Nat.Compare", + "root": "lean", + "source_path": "src/lean/Init/Data/Nat/Compare.lean", + "source_sha256": "128c21cb8fe43c1b9fc34878dcfbb94419f331afba8478dadba828d12454eae4", + "object_path": "lib/lean/Init/Data/Nat/Compare.olean", + "object_sha256": "0fcaeff182f7f483d04ec9a7fee7c9d1d8a62659fea71aef99bc265f0e56d676", + "object_bytes": 39640, + "imports": [ + "Init.Data.Ord" + ] + }, + { + "module": "Init.Data.Nat.Fold", + "root": "lean", + "source_path": "src/lean/Init/Data/Nat/Fold.lean", + "source_sha256": "a74ffb7eaa46fecfe625cff14f5963c789a6f2e169b920d15863c6ffcba7eb61", + "object_path": "lib/lean/Init/Data/Nat/Fold.olean", + "object_sha256": "7bfaec4cfa49a4d37d4e68c7777b235b2c2988b917456ae25997372f274640c8", + "object_bytes": 215096, + "imports": [ + "Init.Omega", + "Init.Data.List.FinRange" + ] + }, + { + "module": "Init.Data.Nat", + "root": "lean", + "source_path": "src/lean/Init/Data/Nat.lean", + "source_sha256": "271c49475a366142bcb612dedcaa919a52e769b1323a46d2d2db5c560e8a83bb", + "object_path": "lib/lean/Init/Data/Nat.olean", + "object_sha256": "6899b91b6fa5af1864dc09522cd08ebc6ea920f3932e4632432e73a6bcaa0039", + "object_bytes": 19696, + "imports": [ + "Init.Data.Nat.Basic", + "Init.Data.Nat.Div", + "Init.Data.Nat.Dvd", + "Init.Data.Nat.Gcd", + "Init.Data.Nat.MinMax", + "Init.Data.Nat.Bitwise", + "Init.Data.Nat.Control", + "Init.Data.Nat.Log2", + "Init.Data.Nat.Power2", + "Init.Data.Nat.Linear", + "Init.Data.Nat.SOM", + "Init.Data.Nat.Lemmas", + "Init.Data.Nat.Mod", + "Init.Data.Nat.Lcm", + "Init.Data.Nat.Compare", + "Init.Data.Nat.Simproc", + "Init.Data.Nat.Fold" + ] + }, + { + "module": "Init.Data.BitVec", + "root": "lean", + "source_path": "src/lean/Init/Data/BitVec.lean", + "source_sha256": "e10c368b2544bee6c51e08124dd896fea24a16d33b7baa325d9949b493e9297b", + "object_path": "lib/lean/Init/Data/BitVec.olean", + "object_sha256": "10cce28885c1917d9f29fe1cd2e6bd7a4a237b2d15fd564bba577cff548762f9", + "object_bytes": 18352, + "imports": [ + "Init.Data.BitVec.Basic", + "Init.Data.BitVec.Bitblast", + "Init.Data.BitVec.Folds", + "Init.Data.BitVec.Lemmas" + ] + }, + { + "module": "Init.Data.Char.Lemmas", + "root": "lean", + "source_path": "src/lean/Init/Data/Char/Lemmas.lean", + "source_sha256": "4119bda557031e6564d584ead6291a4e84daf07d4febec7f72469028176f9d08", + "object_path": "lib/lean/Init/Data/Char/Lemmas.olean", + "object_sha256": "03f8eb3162475d8443c1c5d54d02f6466bdeab033fd6f7395ca90f5838cff3ed", + "object_bytes": 62544, + "imports": [ + "Init.Data.Char.Basic", + "Init.Data.UInt.Lemmas" + ] + }, + { + "module": "Init.Data.Char", + "root": "lean", + "source_path": "src/lean/Init/Data/Char.lean", + "source_sha256": "dca343d4e88ef77c83654f8ab87a5b12da81e452802bfad2fd2d3a7981713073", + "object_path": "lib/lean/Init/Data/Char.olean", + "object_sha256": "bfed746ff0421be07b81a0b852bb64e18da56e1d26aabec21dd15e338ad69d90", + "object_bytes": 18136, + "imports": [ + "Init.Data.Char.Basic", + "Init.Data.Char.Lemmas" + ] + }, + { + "module": "Init.Data.List.Lex", + "root": "lean", + "source_path": "src/lean/Init/Data/List/Lex.lean", + "source_sha256": "38218ab387d136fa04e52190389db0d2c1acd4fdeffbef2b82cfefc1ee6de03b", + "object_path": "lib/lean/Init/Data/List/Lex.olean", + "object_sha256": "359e0c7c56ee4b6e4e5bc8aed743d2dee77003f252175203b004ae5374a5c188", + "object_bytes": 698728, + "imports": [ + "Init.Data.List.Lemmas", + "Init.Data.List.Nat.TakeDrop" + ] + }, + { + "module": "Init.Data.String.Lemmas", + "root": "lean", + "source_path": "src/lean/Init/Data/String/Lemmas.lean", + "source_sha256": "928ead670b618b4fd268e710309f0c85456a1326057e204a473f95f7ac54cde1", + "object_path": "lib/lean/Init/Data/String/Lemmas.olean", + "object_sha256": "573839c2a3a29f7538d28b89e4fb3370818219281013a645daabd6057791d6b5", + "object_bytes": 28896, + "imports": [ + "Init.Data.Char.Lemmas", + "Init.Data.List.Lex" + ] + }, + { + "module": "Init.Data.String", + "root": "lean", + "source_path": "src/lean/Init/Data/String.lean", + "source_sha256": "1705ffddb1e156b4867d9879d300607c71f1b738e06db75e46e0dccd8ce0a168", + "object_path": "lib/lean/Init/Data/String.olean", + "object_sha256": "2ebc2dc1d08baaacdfb028f0083a5508fb153c4204e3ca3077a7ac869612eaf5", + "object_bytes": 18240, + "imports": [ + "Init.Data.String.Basic", + "Init.Data.String.Extra", + "Init.Data.String.Lemmas" + ] + }, + { + "module": "Init.Data.List.Nat.Pairwise", + "root": "lean", + "source_path": "src/lean/Init/Data/List/Nat/Pairwise.lean", + "source_sha256": "85beaa71a1a2d892e35050b1abc2609d1997132766353dc1dc5d60e9b7eb1cf0", + "object_path": "lib/lean/Init/Data/List/Nat/Pairwise.olean", + "object_sha256": "a87671e0805592e41b193ba61c42c5b1eb1065fcf1b71059c962305df0ea7de9", + "object_bytes": 65224, + "imports": [ + "Init.Data.Fin.Lemmas", + "Init.Data.List.Nat.TakeDrop", + "Init.Data.List.Pairwise" + ] + }, + { + "module": "Init.Data.List.Nat.Sublist", + "root": "lean", + "source_path": "src/lean/Init/Data/List/Nat/Sublist.lean", + "source_sha256": "c4e11b601512461c830821158cb621d24bdf4d00fd9759f4039cfb0f61811982", + "object_path": "lib/lean/Init/Data/List/Nat/Sublist.olean", + "object_sha256": "a62c2d1895459e6b8a1ffeee92c999e76d163a7d97d9c86e04686cdf916e8be4", + "object_bytes": 68736, + "imports": [ + "Init.Data.List.Sublist", + "Init.Data.List.Nat.Basic", + "Init.Data.List.Nat.TakeDrop", + "Init.Data.Nat.Lemmas" + ] + }, + { + "module": "Init.Data.List.Nat.Find", + "root": "lean", + "source_path": "src/lean/Init/Data/List/Nat/Find.lean", + "source_sha256": "ce8f1d6cb957850c062af4e636cfac92a2933ab503056128e0dac822d74858ae", + "object_path": "lib/lean/Init/Data/List/Nat/Find.olean", + "object_sha256": "931c36b5a84c9dc6ac925ac110071aecd699a3f9b0d757c7a11d56460c0098e9", + "object_bytes": 43448, + "imports": [ + "Init.Data.List.Nat.Range", + "Init.Data.List.Find" + ] + }, + { + "module": "Init.Data.List.Perm", + "root": "lean", + "source_path": "src/lean/Init/Data/List/Perm.lean", + "source_sha256": "d14e45cd3731a275e99790c4ba5e7019aefdab7da9b9f7d83b64e55d5a7dd8e6", + "object_path": "lib/lean/Init/Data/List/Perm.olean", + "object_sha256": "b334c1a591ad0661fa0a06a4fef9e9e167e3f1731c3a6d7d9a9d37eb3ad8e371", + "object_bytes": 456784, + "imports": [ + "Init.Data.List.Pairwise", + "Init.Data.List.Erase", + "Init.Data.List.Find", + "Init.Data.List.Attach" + ] + }, + { + "module": "Init.Data.List.Nat.Perm", + "root": "lean", + "source_path": "src/lean/Init/Data/List/Nat/Perm.lean", + "source_sha256": "241a4857060e81a213ee37790b481c6b5e67ca8857b96b03a10c51ca14956a3a", + "object_path": "lib/lean/Init/Data/List/Nat/Perm.olean", + "object_sha256": "87fcc71ca23d08b740763a7494597dd981e3b2e3d4e71c593d98be3e5a86874e", + "object_bytes": 39304, + "imports": [ + "Init.Data.List.Nat.TakeDrop", + "Init.Data.List.Perm" + ] + }, + { + "module": "Init.Data.List.Nat", + "root": "lean", + "source_path": "src/lean/Init/Data/List/Nat.lean", + "source_sha256": "5a836ca202d2fabfe694e5d9c5309c14ba2add3e87be335e9aeddfd03bc6c850", + "object_path": "lib/lean/Init/Data/List/Nat.olean", + "object_sha256": "b9cf221839138f041716849331f66d44c6bd06475c37b19c2f87460a19e72af4", + "object_bytes": 19272, + "imports": [ + "Init.Data.List.Nat.Basic", + "Init.Data.List.Nat.Pairwise", + "Init.Data.List.Nat.Range", + "Init.Data.List.Nat.Sublist", + "Init.Data.List.Nat.TakeDrop", + "Init.Data.List.Nat.Count", + "Init.Data.List.Nat.Erase", + "Init.Data.List.Nat.Find", + "Init.Data.List.Nat.BEq", + "Init.Data.List.Nat.Modify", + "Init.Data.List.Nat.InsertIdx", + "Init.Data.List.Nat.Perm" + ] + }, + { + "module": "Init.Data.List.Sort.Basic", + "root": "lean", + "source_path": "src/lean/Init/Data/List/Sort/Basic.lean", + "source_sha256": "a8e9a3f172db5ca2b8e608bb9ebdea3b31902cefb98e8f804a03a9d3413fa747", + "object_path": "lib/lean/Init/Data/List/Sort/Basic.olean", + "object_sha256": "f54976511c9b3162d078edbe88cdc58d0d981b5e41875266c153868d3c4a4382", + "object_bytes": 198968, + "imports": [ + "Init.Data.List.Impl", + "Init.Data.List.Nat.TakeDrop" + ] + }, + { + "module": "Init.Data.List.Sort.Lemmas", + "root": "lean", + "source_path": "src/lean/Init/Data/List/Sort/Lemmas.lean", + "source_sha256": "2a5d562fa20372cdb97bb9ff8431a6cd7b80e80e051166e70eaebb2dab9cacf3", + "object_path": "lib/lean/Init/Data/List/Sort/Lemmas.olean", + "object_sha256": "5eb84b60e8deac1892ff77ef0d4674f240f904a01f7c6c901a4baf220852c45c", + "object_bytes": 337912, + "imports": [ + "Init.Data.List.Perm", + "Init.Data.List.Sort.Basic", + "Init.Data.List.Nat.Range", + "Init.Data.Bool" + ] + }, + { + "module": "Init.Data.List.Sort.Impl", + "root": "lean", + "source_path": "src/lean/Init/Data/List/Sort/Impl.lean", + "source_sha256": "47c4b6efbe5e665a29b9d0861ef2ab854a5049cfbb8c018aad0758ced094bfec", + "object_path": "lib/lean/Init/Data/List/Sort/Impl.olean", + "object_sha256": "13eaaad4aadb53ab65dd50a046d1dd75a08adc56ab3657f9fd3291222e3829be", + "object_bytes": 437096, + "imports": [ + "Init.Data.List.Sort.Basic", + "Init.Data.List.Sort.Lemmas" + ] + }, + { + "module": "Init.Data.List.Sort", + "root": "lean", + "source_path": "src/lean/Init/Data/List/Sort.lean", + "source_sha256": "d714259dfd0511af92e17a3abb39cebeb589f8a34fdcac0009934447f9f8d949", + "object_path": "lib/lean/Init/Data/List/Sort.olean", + "object_sha256": "14babfd0e2ad42f902ce8de38c4f88890f2297dadfcc72202cd469c46e6fd618", + "object_bytes": 18312, + "imports": [ + "Init.Data.List.Sort.Basic", + "Init.Data.List.Sort.Impl", + "Init.Data.List.Sort.Lemmas" + ] + }, + { + "module": "Init.Data.List", + "root": "lean", + "source_path": "src/lean/Init/Data/List.lean", + "source_sha256": "0894c3e201aec05d87706d82a5e167b203fcdafa93f1d6a6406c606b8bba7f21", + "object_path": "lib/lean/Init/Data/List.olean", + "object_sha256": "c13cdacf6cb803bda559b99e29f0d3d2d2d307da3cbc3efef11a9511457e4430", + "object_bytes": 20576, + "imports": [ + "Init.Data.List.Attach", + "Init.Data.List.Basic", + "Init.Data.List.BasicAux", + "Init.Data.List.Control", + "Init.Data.List.Count", + "Init.Data.List.Erase", + "Init.Data.List.Find", + "Init.Data.List.Impl", + "Init.Data.List.Lemmas", + "Init.Data.List.MinMax", + "Init.Data.List.Monadic", + "Init.Data.List.Nat", + "Init.Data.List.Notation", + "Init.Data.List.Pairwise", + "Init.Data.List.Sublist", + "Init.Data.List.TakeDrop", + "Init.Data.List.Zip", + "Init.Data.List.Perm", + "Init.Data.List.Sort", + "Init.Data.List.ToArray", + "Init.Data.List.ToArrayImpl", + "Init.Data.List.MapIdx", + "Init.Data.List.OfFn", + "Init.Data.List.FinRange", + "Init.Data.List.Lex" + ] + }, + { + "module": "Init.Data.Int.Compare", + "root": "lean", + "source_path": "src/lean/Init/Data/Int/Compare.lean", + "source_sha256": "73f35ea0d1bd77a6695d1c37d17aa83bb0c278a6e81b2fb3b75e9d2b2acd0443", + "object_path": "lib/lean/Init/Data/Int/Compare.olean", + "object_sha256": "ceb5c644cd0bc92beb38b595a147d3ce146577d8f4954ffcdc504d4ab20f3027", + "object_bytes": 40304, + "imports": [ + "Init.Data.Ord", + "Init.Data.Int.Order" + ] + }, + { + "module": "Init.Data.Int.Gcd", + "root": "lean", + "source_path": "src/lean/Init/Data/Int/Gcd.lean", + "source_sha256": "67f09be2fd17413e66b786a3bc80a83c286eb7f861b9bfc9fdc1bbe9dae5afde", + "object_path": "lib/lean/Init/Data/Int/Gcd.olean", + "object_sha256": "e0543a3b932ae5efeaa9782be49c79d0f6c9f2477e51340b38c7c60d201a31c7", + "object_bytes": 223432, + "imports": [ + "Init.Data.Int.Basic", + "Init.Data.Nat.Gcd", + "Init.Data.Nat.Lcm", + "Init.Data.Int.DivMod.Lemmas", + "Init.Data.Int.Pow" + ] + }, + { + "module": "Init.Data.Int.Cooper", + "root": "lean", + "source_path": "src/lean/Init/Data/Int/Cooper.lean", + "source_sha256": "4ddec433769e4039b30335b60f243fee5d9f2921a927b9b7af3662e3393e8289", + "object_path": "lib/lean/Init/Data/Int/Cooper.olean", + "object_sha256": "d0d1ea82fba7ec760bcea57cab665e1eaa3df1d7b212d8da4be51a1007ccef16", + "object_bytes": 66400, + "imports": [ + "Init.Data.Int.DivMod.Lemmas", + "Init.Data.Int.Gcd" + ] + }, + { + "module": "Init.Data.AC", + "root": "lean", + "source_path": "src/lean/Init/Data/AC.lean", + "source_sha256": "bc7a5d9f3cfe3ff52fc0adb8b8388344943323c4d7001ff449374c605d3a6c4e", + "object_path": "lib/lean/Init/Data/AC.olean", + "object_sha256": "32b2adcebedb1f1368561c95e3f9e50aff43e11f825039dccdae71bcbc43ec0b", + "object_bytes": 396832, + "imports": [ + "Init.Classical", + "Init.ByCases" + ] + }, + { + "module": "Init.Data.Int.Linear", + "root": "lean", + "source_path": "src/lean/Init/Data/Int/Linear.lean", + "source_sha256": "5778a0f6ab9daad4189315bd9784654a9c69b47bbf41b40a3526e2dad03289cf", + "object_path": "lib/lean/Init/Data/Int/Linear.olean", + "object_sha256": "5e363a9c86414aa3c24ed31b1015227a1e02e33ae0423beca2c4afa002a64b68", + "object_bytes": 1135536, + "imports": [ + "Init.ByCases", + "Init.Data.Prod", + "Init.Data.Int.Lemmas", + "Init.Data.Int.LemmasAux", + "Init.Data.Int.DivMod.Bootstrap", + "Init.Data.Int.Cooper", + "Init.Data.Int.Gcd", + "Init.Data.RArray", + "Init.Data.AC" + ] + }, + { + "module": "Init.Data.Int.OfNat", + "root": "lean", + "source_path": "src/lean/Init/Data/Int/OfNat.lean", + "source_sha256": "6e172618a710414af35c80cb4120c9395db88984c63839e8a71809012153618c", + "object_path": "lib/lean/Init/Data/Int/OfNat.olean", + "object_sha256": "e183e26e6c4d167482540cc0e017adf35489422aa26d4bdff9f2f8b22a03a422", + "object_bytes": 186216, + "imports": [ + "Init.Data.Int.Lemmas", + "Init.Data.Int.DivMod", + "Init.Data.Int.Linear", + "Init.Data.RArray" + ] + }, + { + "module": "Init.Data.Int", + "root": "lean", + "source_path": "src/lean/Init/Data/Int.lean", + "source_sha256": "fb79e9440ec0459251e5ddff35bed24e6820155964f5eaf8b8e46e19815a99a2", + "object_path": "lib/lean/Init/Data/Int.olean", + "object_sha256": "1b2ff31a39153fc1b0ffa5fdc82ca1e834464639784896c568f58df0b7baf9d8", + "object_bytes": 19184, + "imports": [ + "Init.Data.Int.Basic", + "Init.Data.Int.Bitwise", + "Init.Data.Int.Compare", + "Init.Data.Int.DivMod", + "Init.Data.Int.Gcd", + "Init.Data.Int.Lemmas", + "Init.Data.Int.LemmasAux", + "Init.Data.Int.Order", + "Init.Data.Int.Pow", + "Init.Data.Int.Cooper", + "Init.Data.Int.Linear", + "Init.Data.Int.OfNat" + ] + }, + { + "module": "Init.Data.Array.QSort.Basic", + "root": "lean", + "source_path": "src/lean/Init/Data/Array/QSort/Basic.lean", + "source_sha256": "3cdab4c1c65a351b90e55f9a1fb1c8db4ba63c6a4386491578bf2d2322849832", + "object_path": "lib/lean/Init/Data/Array/QSort/Basic.olean", + "object_sha256": "d53318d68ffd83e9d633944b9a253ce10aa1fcc9458ed427b9e80342b594ae5f", + "object_bytes": 318304, + "imports": [ + "Init.Data.Vector.Basic", + "Init.Data.Ord" + ] + }, + { + "module": "Init.Data.Array.QSort", + "root": "lean", + "source_path": "src/lean/Init/Data/Array/QSort.lean", + "source_sha256": "8884bc51623ebb55f2a196c42740d62583ef8a7d9542ff641b893ab4b5b29b61", + "object_path": "lib/lean/Init/Data/Array/QSort.olean", + "object_sha256": "0e38198b9bc6a4f2214fb6a65af5be1458b99a43e33c8a8c4977f91d8664035d", + "object_bytes": 18104, + "imports": [ + "Init.Data.Array.QSort.Basic" + ] + }, + { + "module": "Init.Data.Array.BinSearch", + "root": "lean", + "source_path": "src/lean/Init/Data/Array/BinSearch.lean", + "source_sha256": "839a4528c45feda355b2e21d2de018db9268e0fcded80d02043c269b42e87579", + "object_path": "lib/lean/Init/Data/Array/BinSearch.olean", + "object_sha256": "516992dfe01cea7a852817cbdd8cf1b069569f7ce3a213f83f5e8c827c8d0c05", + "object_bytes": 352008, + "imports": [ + "Init.Data.Array.Basic", + "Init.Data.Int.DivMod.Lemmas", + "Init.Omega" + ] + }, + { + "module": "Init.Data.Array.InsertionSort", + "root": "lean", + "source_path": "src/lean/Init/Data/Array/InsertionSort.lean", + "source_sha256": "a2408d53a863c912893d81ea9b10effc8d49d209d335f1ac05b79074e6d708c6", + "object_path": "lib/lean/Init/Data/Array/InsertionSort.olean", + "object_sha256": "3eced3489a741788111339189aceb60b4b448ce413a312d19e31bcbb3a4808a4", + "object_bytes": 96608, + "imports": [ + "Init.Data.Array.Basic" + ] + }, + { + "module": "Init.Data.Array.BasicAux", + "root": "lean", + "source_path": "src/lean/Init/Data/Array/BasicAux.lean", + "source_sha256": "6b42a401acd4d63f0a119be7cf6b145c00c262d3fdaeaf2914ac56b221b7739b", + "object_path": "lib/lean/Init/Data/Array/BasicAux.olean", + "object_sha256": "33bdd6383622d571cb5c9237aa35cdd367ab4c044fc30eacfedec6db66a79537", + "object_bytes": 130376, + "imports": [ + "Init.Data.Array.Basic", + "Init.Data.Nat.Linear", + "Init.NotationExtra" + ] + }, + { + "module": "Init.Data.Array.FinRange", + "root": "lean", + "source_path": "src/lean/Init/Data/Array/FinRange.lean", + "source_sha256": "8ec555258f1c30ddd4c7d84fe7149faae196fef47bf7fce1b1bb4de8006dbb89", + "object_path": "lib/lean/Init/Data/Array/FinRange.olean", + "object_sha256": "f16c546cfafbde001e03048b8c197da9bbfa5718e9d0ed70ab6a69cfe92dba40", + "object_bytes": 37232, + "imports": [ + "Init.Data.List.FinRange", + "Init.Data.Array.OfFn" + ] + }, + { + "module": "Init.Data.Array.Perm", + "root": "lean", + "source_path": "src/lean/Init/Data/Array/Perm.lean", + "source_sha256": "ce105a188a9860bf7038995813eaae5771753ffe26cc0aeeecfbff2b0c219137", + "object_path": "lib/lean/Init/Data/Array/Perm.olean", + "object_sha256": "997bbfde871b6cd1907a3d1b1150e375cca566efd49cb4bedba238ddde6cee7c", + "object_bytes": 113328, + "imports": [ + "Init.Data.List.Nat.Perm", + "Init.Data.Array.Basic", + "Init.Data.Array.Lemmas" + ] + }, + { + "module": "Init.Data.Array.Find", + "root": "lean", + "source_path": "src/lean/Init/Data/Array/Find.lean", + "source_sha256": "4f0470dd8395a5f44f0dba71ec98a936f732b0cad3fb409f8e8e71a2bc4171f2", + "object_path": "lib/lean/Init/Data/Array/Find.olean", + "object_sha256": "da9ed649d91079da1cfe850c90e090b84629ca340412bbd4c707e5ccc4c1a9f1", + "object_bytes": 324872, + "imports": [ + "Init.Data.List.Nat.Find", + "Init.Data.Array.Basic", + "Init.Data.Array.Lemmas", + "Init.Data.Array.Attach", + "Init.Data.Array.Range" + ] + }, + { + "module": "Init.Data.Array.Lex.Lemmas", + "root": "lean", + "source_path": "src/lean/Init/Data/Array/Lex/Lemmas.lean", + "source_sha256": "ef5c435c4b0ac0d10b8337daf2337e2416cda0cbcdafec0fcef3c3d8e862b42c", + "object_path": "lib/lean/Init/Data/Array/Lex/Lemmas.olean", + "object_sha256": "a6a0ddb5f6b5d84d80f0a6ff6fc947abebdeabe2eba2580886a84f839a4be618", + "object_bytes": 209824, + "imports": [ + "Init.Data.Array.Lex.Basic", + "Init.Data.Array.Lemmas", + "Init.Data.List.Lex" + ] + }, + { + "module": "Init.Data.Array.Lex", + "root": "lean", + "source_path": "src/lean/Init/Data/Array/Lex.lean", + "source_sha256": "33b46f8d1387b71b2462f54066f6b6c36fa9b441810e68939656c80f69c6a07b", + "object_path": "lib/lean/Init/Data/Array/Lex.olean", + "object_sha256": "1b59c9c4d7e4115e7b608b670b04715cd21195771426deed88ec67dc9c19b766", + "object_bytes": 18208, + "imports": [ + "Init.Data.Array.Lex.Basic", + "Init.Data.Array.Lex.Lemmas" + ] + }, + { + "module": "Init.Data.Array.Erase", + "root": "lean", + "source_path": "src/lean/Init/Data/Array/Erase.lean", + "source_sha256": "2c7d4288e70feeab3019961a26a13846675ef3e8d11593e3887b6abf32655995", + "object_path": "lib/lean/Init/Data/Array/Erase.olean", + "object_sha256": "9d8710184183ba2c396de245c5c5159823d6b2d5dba949801a3e0409d98a8b49", + "object_bytes": 232928, + "imports": [ + "Init.Data.Array.Basic", + "Init.Data.Array.Lemmas", + "Init.Data.List.Nat.Erase", + "Init.Data.List.Nat.Basic" + ] + }, + { + "module": "Init.Data.Array.Extract", + "root": "lean", + "source_path": "src/lean/Init/Data/Array/Extract.lean", + "source_sha256": "f0a071656fdecc1c3eeff117f2c6b846aa00d8f2b1e65e8f71d1cf208a1f52cc", + "object_path": "lib/lean/Init/Data/Array/Extract.olean", + "object_sha256": "53309df7015137b445e10b81c429f1a45fd2b1ff626d3ca170904898723cd875", + "object_bytes": 140800, + "imports": [ + "Init.Data.Array.Lemmas", + "Init.Data.List.Nat.TakeDrop" + ] + }, + { + "module": "Init.Data.Array", + "root": "lean", + "source_path": "src/lean/Init/Data/Array.lean", + "source_sha256": "0c937bc6dca8ce691aba919896383ef4287120a77371ecccb3c71742529cc169", + "object_path": "lib/lean/Init/Data/Array.olean", + "object_sha256": "88066ab404d45cad77700dc79e2eb306447f2df3f9ef2602a51eacdb115a50a5", + "object_bytes": 20488, + "imports": [ + "Init.Data.Array.Basic", + "Init.Data.Array.QSort", + "Init.Data.Array.BinSearch", + "Init.Data.Array.InsertionSort", + "Init.Data.Array.DecidableEq", + "Init.Data.Array.Mem", + "Init.Data.Array.Attach", + "Init.Data.Array.BasicAux", + "Init.Data.Array.Lemmas", + "Init.Data.Array.TakeDrop", + "Init.Data.Array.Bootstrap", + "Init.Data.Array.GetLit", + "Init.Data.Array.MapIdx", + "Init.Data.Array.Set", + "Init.Data.Array.Monadic", + "Init.Data.Array.FinRange", + "Init.Data.Array.Perm", + "Init.Data.Array.Find", + "Init.Data.Array.Lex", + "Init.Data.Array.Range", + "Init.Data.Array.Erase", + "Init.Data.Array.Zip", + "Init.Data.Array.InsertIdx", + "Init.Data.Array.Extract" + ] + }, + { + "module": "Init.Data.Array.Subarray.Split", + "root": "lean", + "source_path": "src/lean/Init/Data/Array/Subarray/Split.lean", + "source_sha256": "49c7ecfd1b1b33c33318c3954beab31aaa823de149c1a1a2e726c2232ab6197c", + "object_path": "lib/lean/Init/Data/Array/Subarray/Split.olean", + "object_sha256": "fa0f852198f0cd8341ba84a3fd7f086b15d974120d75eccc2481bf2dea6ce330", + "object_bytes": 57976, + "imports": [ + "Init.Data.Array.Basic", + "Init.Data.Array.Subarray", + "Init.Omega" + ] + }, + { + "module": "Init.Data.ByteArray", + "root": "lean", + "source_path": "src/lean/Init/Data/ByteArray.lean", + "source_sha256": "639feffac0500eeca4b984c6af0f71f8c7f90d83135e7b704900bf74e712f77b", + "object_path": "lib/lean/Init/Data/ByteArray.olean", + "object_sha256": "fedd1e9280a7e6120f751535c7545844543d9379fa7bd1571f92197f177ef4c2", + "object_bytes": 18040, + "imports": [ + "Init.Data.ByteArray.Basic" + ] + }, + { + "module": "Init.Data.Float", + "root": "lean", + "source_path": "src/lean/Init/Data/Float.lean", + "source_sha256": "1d8d400f9f3120f9c7d65d113e7b2e59ba7a20520d384c2352ed6916a76065de", + "object_path": "lib/lean/Init/Data/Float.olean", + "object_sha256": "d94f0d07d61cee40aa4d465a019317a6a5536d856bf495ed814c32bf245b21a3", + "object_bytes": 172504, + "imports": [ + "Init.Core", + "Init.Data.Int.Basic", + "Init.Data.ToString.Basic" + ] + }, + { + "module": "Init.Data.FloatArray.Basic", + "root": "lean", + "source_path": "src/lean/Init/Data/FloatArray/Basic.lean", + "source_sha256": "cb93e3458d21ef803a4dac81133e28a23dc7120ed6982d7fa5a69c0c2afe305b", + "object_path": "lib/lean/Init/Data/FloatArray/Basic.olean", + "object_sha256": "20008b0e3c8e8f76f4f3dee9ccb91fe634eaf66264f3d91287d881d6f0520fe6", + "object_bytes": 240072, + "imports": [ + "Init.Data.Array.Basic", + "Init.Data.Float", + "Init.Data.Option.Basic" + ] + }, + { + "module": "Init.Data.FloatArray", + "root": "lean", + "source_path": "src/lean/Init/Data/FloatArray.lean", + "source_sha256": "07423926b73aa1f5c73bae610c238e2bdb0792b7d7a8037fb0b281229e8e17a5", + "object_path": "lib/lean/Init/Data/FloatArray.olean", + "object_sha256": "20f3cb04ca98ad73d39077bab32b1f998e6e58f3f1f531eab321963a816d90e8", + "object_bytes": 18040, + "imports": [ + "Init.Data.FloatArray.Basic" + ] + }, + { + "module": "Init.Data.Fin", + "root": "lean", + "source_path": "src/lean/Init/Data/Fin.lean", + "source_sha256": "25c6ffa68ded80b9e10978a11b53f892321502b5084143c07aea6ab26d1cc59e", + "object_path": "lib/lean/Init/Data/Fin.olean", + "object_sha256": "fb4aaba9e542df6835d5f397604f6ce7e814f481b657d1db7a2225e8f2b69d87", + "object_bytes": 18448, + "imports": [ + "Init.Data.Fin.Basic", + "Init.Data.Fin.Log2", + "Init.Data.Fin.Iterate", + "Init.Data.Fin.Fold", + "Init.Data.Fin.Lemmas" + ] + }, + { + "module": "Init.Data.SInt.Float", + "root": "lean", + "source_path": "src/lean/Init/Data/SInt/Float.lean", + "source_sha256": "4abca163b09599837ca6d11ab288bf5cd067c2d338465ace6efd228e2cbb0dcd", + "object_path": "lib/lean/Init/Data/SInt/Float.olean", + "object_sha256": "233d68f47c391965f20a539587b06a8e706a95807102b6af83495543a13492d7", + "object_bytes": 33864, + "imports": [ + "Init.Data.Float", + "Init.Data.SInt.Basic" + ] + }, + { + "module": "Init.Data.Float32", + "root": "lean", + "source_path": "src/lean/Init/Data/Float32.lean", + "source_sha256": "1dbb65b2f42ea9b8f5be39fa81b61663e418ebfaeb5c4b17e441efc73b5e49ec", + "object_path": "lib/lean/Init/Data/Float32.olean", + "object_sha256": "7df77ff6bc7b84a1d00d2667c5b0a8503055aa1d3145d988dce96afe4b5b94e7", + "object_bytes": 150712, + "imports": [ + "Init.Core", + "Init.Data.Int.Basic", + "Init.Data.ToString.Basic", + "Init.Data.Float" + ] + }, + { + "module": "Init.Data.SInt.Float32", + "root": "lean", + "source_path": "src/lean/Init/Data/SInt/Float32.lean", + "source_sha256": "8fe20e83b51e0aa98b77346492d0bd1728e819641d05aa3a8bd5e36f3313ec79", + "object_path": "lib/lean/Init/Data/SInt/Float32.olean", + "object_sha256": "450f56a5299a3059adfe62f1e639ce2f059e8cbb0ac9811389f370db94f49a01", + "object_bytes": 34152, + "imports": [ + "Init.Data.Float32", + "Init.Data.SInt.Basic" + ] + }, + { + "module": "Init.Data.SInt.Lemmas", + "root": "lean", + "source_path": "src/lean/Init/Data/SInt/Lemmas.lean", + "source_sha256": "29aeb002da04ca6dc409715601a3863eef715c97730cf74ec1bc77bfc7bc7d83", + "object_path": "lib/lean/Init/Data/SInt/Lemmas.olean", + "object_sha256": "08801c5e0c0d76f442fe38379436f8a712eefbe651532bbe2affeeba093308f8", + "object_bytes": 1441792, + "imports": [ + "Init.Data.Nat.Bitwise.Basic", + "Init.Data.SInt.Basic", + "Init.Data.BitVec.Basic", + "Init.Data.BitVec.Bitblast", + "Init.Data.BitVec.Lemmas", + "Init.Data.Int.LemmasAux", + "Init.Data.UInt.Basic", + "Init.Data.UInt.Lemmas", + "Init.System.Platform" + ] + }, + { + "module": "Init.Data.SInt.Bitwise", + "root": "lean", + "source_path": "src/lean/Init/Data/SInt/Bitwise.lean", + "source_sha256": "973ca0fcd8d5137ea15d52abff3f42454653cf6126d6185c84218de77569f1da", + "object_path": "lib/lean/Init/Data/SInt/Bitwise.olean", + "object_sha256": "1dfc6eeacd37e09c44e6f35e77b20cfe48a55c9d71a1b36c81f9a0069210d8c9", + "object_bytes": 628848, + "imports": [ + "Init.Data.UInt.Basic", + "Init.Data.UInt.Bitwise", + "Init.Data.BitVec.Basic", + "Init.Data.BitVec.Lemmas", + "Init.Data.SInt.Basic", + "Init.Data.SInt.Lemmas" + ] + }, + { + "module": "Init.Data.SInt", + "root": "lean", + "source_path": "src/lean/Init/Data/SInt.lean", + "source_sha256": "a6813372a504c1dd2b2641eb12bc1b49abb0b7833d92a58fed12944f3b0fd195", + "object_path": "lib/lean/Init/Data/SInt.olean", + "object_sha256": "3a9b154ac1dbaafe450ebdd112d8f11097ad0d549eeaf9a622c15c3438852453", + "object_bytes": 18448, + "imports": [ + "Init.Data.SInt.Basic", + "Init.Data.SInt.Float", + "Init.Data.SInt.Float32", + "Init.Data.SInt.Lemmas", + "Init.Data.SInt.Bitwise" + ] + }, + { + "module": "Init.Data.Option.Coe", + "root": "lean", + "source_path": "src/lean/Init/Data/Option/Coe.lean", + "source_sha256": "0672b1ef5edf8c695aa371af53f4d5fcd48377c8ce1628267d7c27d00f696ba1", + "object_path": "lib/lean/Init/Data/Option/Coe.olean", + "object_sha256": "d5bfc55fbfcf12769ebf00e589e04a89f3c986cbfbb855f68d6a949504b40407", + "object_bytes": 22072, + "imports": [ + "Init.Coe" + ] + }, + { + "module": "Init.Data.Option.Monadic", + "root": "lean", + "source_path": "src/lean/Init/Data/Option/Monadic.lean", + "source_sha256": "10ed5bc5a3db302b345c6d6abd8dcf05a0b08c339eebff12cb536197e9e04bb1", + "object_path": "lib/lean/Init/Data/Option/Monadic.olean", + "object_sha256": "01de4812b6e97d628ca4f00ceec5b6a755cf016797151b43b80e58f13d7028c5", + "object_bytes": 144528, + "imports": [ + "Init.Data.Option.Instances", + "Init.Data.Option.Attach", + "Init.Control.Lawful.Basic" + ] + }, + { + "module": "Init.Data.Option", + "root": "lean", + "source_path": "src/lean/Init/Data/Option.lean", + "source_sha256": "e4275976e19597180b4d925db78baf1990d61fb6f16b8e8b2c5a4213be9aa0b9", + "object_path": "lib/lean/Init/Data/Option.olean", + "object_sha256": "66c0ad059329a0efe3589259b9b27c4f9511ef2745b2023970c19dd3993ba2c0", + "object_bytes": 18880, + "imports": [ + "Init.Data.Option.Basic", + "Init.Data.Option.BasicAux", + "Init.Data.Option.Coe", + "Init.Data.Option.Instances", + "Init.Data.Option.Lemmas", + "Init.Data.Option.Attach", + "Init.Data.Option.List", + "Init.Data.Option.Monadic", + "Init.Data.Option.Array" + ] + }, + { + "module": "Init.System.IOError", + "root": "lean", + "source_path": "src/lean/Init/System/IOError.lean", + "source_sha256": "fd97845fa005300a4af3eb00ad96ef82452491ff9431bb85dabad9f37d44e9f3", + "object_path": "lib/lean/Init/System/IOError.olean", + "object_sha256": "dc9f58fde13a98465611b3c25ea501549728349f36f7d43a6e5be86ad663d5c4", + "object_bytes": 286768, + "imports": [ + "Init.Data.ToString.Basic" + ] + }, + { + "module": "Init.System.FilePath", + "root": "lean", + "source_path": "src/lean/Init/System/FilePath.lean", + "source_sha256": "bb2555758b353d1835e3e61ffe1a3f79ef2ceb5eb4b4229fd1313e897916dd92", + "object_path": "lib/lean/Init/System/FilePath.olean", + "object_sha256": "ee6856c66711f5c3b9b28d8cb2ca7b34956ff186089dbf2288fc6d9e8c99ce50", + "object_bytes": 227312, + "imports": [ + "Init.System.Platform", + "Init.Data.ToString.Basic" + ] + }, + { + "module": "Init.System.IO", + "root": "lean", + "source_path": "src/lean/Init/System/IO.lean", + "source_sha256": "1c296c28db3a1e8b5ca3888773c8618e38e9681808f05ddb868d15ff84a47628", + "object_path": "lib/lean/Init/System/IO.olean", + "object_sha256": "b0c327358020ee4b9dc2f5f4491f3ba749023e8421a2d5aeb8ded0eff8f5efaa", + "object_bytes": 1320352, + "imports": [ + "Init.System.IOError", + "Init.System.FilePath", + "Init.System.ST", + "Init.Data.Ord", + "Init.Data.String.Extra" + ] + }, + { + "module": "Init.Data.Random", + "root": "lean", + "source_path": "src/lean/Init/Data/Random.lean", + "source_sha256": "d628cff49b6482f238c896c97f679e2d225618e78516c3d414a231c073f62f75", + "object_path": "lib/lean/Init/Data/Random.olean", + "object_sha256": "9c2180afaa097c57dc93a6e41c59412b2997cbd1366709e9682c73dae4fd4855", + "object_bytes": 229576, + "imports": [ + "Init.System.IO" + ] + }, + { + "module": "Init.Data.ToString", + "root": "lean", + "source_path": "src/lean/Init/Data/ToString.lean", + "source_sha256": "33fc5feabe02d43e65e2af09833226be57bbefb328610be02f9c4d5f29259d3d", + "object_path": "lib/lean/Init/Data/ToString.olean", + "object_sha256": "2e1d73d22420ac20c130d628228791e4e635c930a8c591910cd7d05e2446a4c8", + "object_bytes": 18144, + "imports": [ + "Init.Data.ToString.Basic", + "Init.Data.ToString.Macro" + ] + }, + { + "module": "Init.Data.Hashable", + "root": "lean", + "source_path": "src/lean/Init/Data/Hashable.lean", + "source_sha256": "483a04a035715af1105a126cdf02c8963c5b7307757ccd81aca4e97e346484bb", + "object_path": "lib/lean/Init/Data/Hashable.olean", + "object_sha256": "bf6d6d6de4becbfc2a5a8e93795f1921745730768f762b12c179e5225251e80e", + "object_bytes": 126776, + "imports": [ + "Init.Data.UInt.Basic", + "Init.Data.String.Basic", + "Init.Data.ByteArray.Basic" + ] + }, + { + "module": "Init.Data.OfScientific", + "root": "lean", + "source_path": "src/lean/Init/Data/OfScientific.lean", + "source_sha256": "05f492505988dcd4ade6c124f82ead292b5e56f86f30a1bd7483f3bf5344f485", + "object_path": "lib/lean/Init/Data/OfScientific.olean", + "object_sha256": "fc021e4577285e325b5f44032f35003460aae754fa31802e6c6d21d8e93f88c9", + "object_bytes": 92416, + "imports": [ + "Init.Meta", + "Init.Data.Float", + "Init.Data.Float32", + "Init.Data.Nat.Log2" + ] + }, + { + "module": "Init.Data.Format.Macro", + "root": "lean", + "source_path": "src/lean/Init/Data/Format/Macro.lean", + "source_sha256": "17832754c5230fef7fbd1660f73faad8a55199ab9fd228e6f69bac20d167fac3", + "object_path": "lib/lean/Init/Data/Format/Macro.olean", + "object_sha256": "1ecdee2e8321936207185a946e690fca79884dacdca8b97c8660c286abdbc1ae", + "object_bytes": 66192, + "imports": [ + "Init.Data.Format.Basic", + "Init.Data.ToString.Macro" + ] + }, + { + "module": "Init.Data.Format.Instances", + "root": "lean", + "source_path": "src/lean/Init/Data/Format/Instances.lean", + "source_sha256": "972baf1049a8dddbc488f4afa451602f07d6428869ea0171c02c2d04ff94a842", + "object_path": "lib/lean/Init/Data/Format/Instances.olean", + "object_sha256": "2cf4dd7fe7b976f378354bca549446ac03cb90ef029c99569bb4d67e966a3408", + "object_bytes": 98520, + "imports": [ + "Init.Data.Format.Basic", + "Init.Data.Array.Basic", + "Init.Data.ToString.Basic" + ] + }, + { + "module": "Init.Data.Format.Syntax", + "root": "lean", + "source_path": "src/lean/Init/Data/Format/Syntax.lean", + "source_sha256": "1f7e4fa21ee0442fc1769d823268d7d5137c89f2301f2bcfa1adadc1e1e64f93", + "object_path": "lib/lean/Init/Data/Format/Syntax.olean", + "object_sha256": "311d858368cae3a63ec6e3baf9b5aaf1463913cb0e00cfc5f1fc942480b24e51", + "object_bytes": 174424, + "imports": [ + "Init.Data.Format.Macro", + "Init.Data.Format.Instances", + "Init.Meta" + ] + }, + { + "module": "Init.Data.Format", + "root": "lean", + "source_path": "src/lean/Init/Data/Format.lean", + "source_sha256": "a460cbb6b0b30fa4dec87eae0f25606207ab43900273849ed5e84aaaae796de0", + "object_path": "lib/lean/Init/Data/Format.olean", + "object_sha256": "ddf73ea49fd9dd015948aeb483e4419aa8129679adcc45381104178509120e67", + "object_bytes": 18352, + "imports": [ + "Init.Data.Format.Basic", + "Init.Data.Format.Macro", + "Init.Data.Format.Instances", + "Init.Data.Format.Syntax" + ] + }, + { + "module": "Init.Data.Queue", + "root": "lean", + "source_path": "src/lean/Init/Data/Queue.lean", + "source_sha256": "4c7afed15726c2ece8d065e03a740beeeabdcc7a484dc6ead151ac4c7ad709d3", + "object_path": "lib/lean/Init/Data/Queue.olean", + "object_sha256": "4abcbe3eec5bee490dfe07f53725d21908254a6f687aec5aed16d7e2f2976ab7", + "object_bytes": 104008, + "imports": [ + "Init.Data.List.Control" + ] + }, + { + "module": "Init.Data.Sum.Basic", + "root": "lean", + "source_path": "src/lean/Init/Data/Sum/Basic.lean", + "source_sha256": "cc3af2a2ecab1b78b558b5d717f06bfee264c4aa9005e3b038714f58b96a4d57", + "object_path": "lib/lean/Init/Data/Sum/Basic.olean", + "object_sha256": "20eb88baf56ce75f991f3e8854ae43ac49b6fb11e9add16961b40ac89a6cef9b", + "object_bytes": 227480, + "imports": [ + "Init.PropLemmas" + ] + }, + { + "module": "Init.Data.Sum.Lemmas", + "root": "lean", + "source_path": "src/lean/Init/Data/Sum/Lemmas.lean", + "source_sha256": "13d34c99e364ce12f9eaed002215d74c36594149e79838632d1cb0f3fd708e96", + "object_path": "lib/lean/Init/Data/Sum/Lemmas.olean", + "object_sha256": "7a593534f639a9c4e8a326ae2979163eaa129fb1b5db2be51ef4c8b8acedd5b6", + "object_bytes": 177088, + "imports": [ + "Init.Data.Sum.Basic", + "Init.Ext" + ] + }, + { + "module": "Init.Data.Sum", + "root": "lean", + "source_path": "src/lean/Init/Data/Sum.lean", + "source_sha256": "0ef7a6fd593fa01bb4aef920a60a79b6ddc6c0b74446cd29baf4433335e18d0a", + "object_path": "lib/lean/Init/Data/Sum.olean", + "object_sha256": "134586aa0d27a4a8a10405cc01f5cbe94ea490a6f76326ce169d8ca8ad014d9d", + "object_bytes": 18136, + "imports": [ + "Init.Data.Sum.Basic", + "Init.Data.Sum.Lemmas" + ] + }, + { + "module": "Init.Data.ULift", + "root": "lean", + "source_path": "src/lean/Init/Data/ULift.lean", + "source_sha256": "9980c1bb801450b34ff805cda7e57674667cd710bb10ad285026cba3616f5eca", + "object_path": "lib/lean/Init/Data/ULift.olean", + "object_sha256": "4c8f5880fd4b26d9e729b38ec4b1e9b5c5b86e23ac7ae1180beb7c648e2ca321", + "object_bytes": 37912, + "imports": [ + "Init.Core" + ] + }, + { + "module": "Init.Data.PLift", + "root": "lean", + "source_path": "src/lean/Init/Data/PLift.lean", + "source_sha256": "47ada2e0594f31149e76b1180d1e852cc37745dd96b356ed9840713e9b023e8e", + "object_path": "lib/lean/Init/Data/PLift.olean", + "object_sha256": "7074cebc6b11744cf332597fa2c32643f38ca7b7dfe5a44a7c779b1642fb0dfc", + "object_bytes": 37336, + "imports": [ + "Init.Core" + ] + }, + { + "module": "Init.Data.Vector.Lemmas", + "root": "lean", + "source_path": "src/lean/Init/Data/Vector/Lemmas.lean", + "source_sha256": "cd48d6d0173ffad8a2b292e98b033dafad9e3fd224061ae65adab1974e7f756f", + "object_path": "lib/lean/Init/Data/Vector/Lemmas.olean", + "object_sha256": "e392b10245a6a70fd1e969d6435e6cfaa4ea9c2cf77da26f16245a51e83c27f3", + "object_bytes": 1304648, + "imports": [ + "Init.Data.Array.Basic", + "Init.Data.Vector.Basic", + "Init.Data.Array.Attach", + "Init.Data.Array.Find" + ] + }, + { + "module": "Init.Data.Vector.Lex", + "root": "lean", + "source_path": "src/lean/Init/Data/Vector/Lex.lean", + "source_sha256": "8ec3a80f2675451f9241a985c72fb476fa95e955c706b093070971bdf3598e17", + "object_path": "lib/lean/Init/Data/Vector/Lex.olean", + "object_sha256": "297a63988f697f6f2bf0067a9e6e01b6c41e23eaae77929c915409d66c8db6ce", + "object_bytes": 217136, + "imports": [ + "Init.Data.Vector.Basic", + "Init.Data.Vector.Lemmas", + "Init.Data.Array.Lex.Basic", + "Init.Data.Array.Lex.Lemmas" + ] + }, + { + "module": "Init.Data.Vector.Attach", + "root": "lean", + "source_path": "src/lean/Init/Data/Vector/Attach.lean", + "source_sha256": "1528a9bdd0fe9ebf7cd298866a0d888e66b989eaee74bc798f72867ddcd791dd", + "object_path": "lib/lean/Init/Data/Vector/Attach.olean", + "object_sha256": "062bafe0f45f33e588248247240e20e05adbf1a665be17b1ea2fb78f0ce48d59", + "object_bytes": 329264, + "imports": [ + "Init.Data.Vector.Lemmas", + "Init.Data.Array.Attach" + ] + }, + { + "module": "Init.Data.Vector.MapIdx", + "root": "lean", + "source_path": "src/lean/Init/Data/Vector/MapIdx.lean", + "source_sha256": "bc28ab8c4cbc5ba782270f20ced842c4af0ed0446968ab50d2bed2ca89457fc0", + "object_path": "lib/lean/Init/Data/Vector/MapIdx.olean", + "object_sha256": "09a4d4a14b30386f10f24c054ff96592ab6d323246ee67a9988714ee7095b94b", + "object_bytes": 234656, + "imports": [ + "Init.Data.Array.MapIdx", + "Init.Data.Array.Basic", + "Init.Data.Vector.Basic", + "Init.Data.Vector.Attach", + "Init.Data.Vector.Lemmas" + ] + }, + { + "module": "Init.Data.Vector.Count", + "root": "lean", + "source_path": "src/lean/Init/Data/Vector/Count.lean", + "source_sha256": "eebec80e6e4ecc19457f14acee3eb3fd262b28bab42a14a9f59496ea3fedaebf", + "object_path": "lib/lean/Init/Data/Vector/Count.olean", + "object_sha256": "dfe2730c5e1edab5a678e993e8918e8d9402e9fa7e6c53ae178ec36845f898f0", + "object_bytes": 110368, + "imports": [ + "Init.Data.Array.Count", + "Init.Data.Vector.Basic", + "Init.Data.Vector.Lemmas" + ] + }, + { + "module": "Init.Data.Vector.DecidableEq", + "root": "lean", + "source_path": "src/lean/Init/Data/Vector/DecidableEq.lean", + "source_sha256": "e6d821581dc3b21213e4b109dc818a13a77f9528a622ae14cec9fac03cf713e6", + "object_path": "lib/lean/Init/Data/Vector/DecidableEq.olean", + "object_sha256": "f9113c71e906384dc09e7a0d2e9e17ab010641b0ca60fb83c135c61308e91f7c", + "object_bytes": 42600, + "imports": [ + "Init.Data.Array.DecidableEq", + "Init.Data.Vector.Lemmas" + ] + }, + { + "module": "Init.Data.Vector.Zip", + "root": "lean", + "source_path": "src/lean/Init/Data/Vector/Zip.lean", + "source_sha256": "c5558c2cf06e0060d38369517258799fe9877db0ed6f80bf1264bd81256c9d9b", + "object_path": "lib/lean/Init/Data/Vector/Zip.olean", + "object_sha256": "5a5c282e389ede77a3813d352754d65a7b79d0e3fe948674e9967702e5394cee", + "object_bytes": 176904, + "imports": [ + "Init.Data.Array.Basic", + "Init.Data.Array.Zip", + "Init.Data.Vector.Basic", + "Init.Data.Vector.Lemmas" + ] + }, + { + "module": "Init.Data.Vector.Monadic", + "root": "lean", + "source_path": "src/lean/Init/Data/Vector/Monadic.lean", + "source_sha256": "9308e869c151fc2e10967843b2d50f5d52b3a8c21d4c139c399cd3704155996c", + "object_path": "lib/lean/Init/Data/Vector/Monadic.olean", + "object_sha256": "c7f563237e6534a9babe5fecbae731628c9bd0aac3fcef3717f1cc586b7e7af3", + "object_bytes": 134280, + "imports": [ + "Init.Data.Vector.Basic", + "Init.Data.Vector.Lemmas", + "Init.Data.Vector.Attach", + "Init.Data.Array.Monadic", + "Init.Control.Lawful.Lemmas" + ] + }, + { + "module": "Init.Data.Vector.OfFn", + "root": "lean", + "source_path": "src/lean/Init/Data/Vector/OfFn.lean", + "source_sha256": "c04c2b771909a0eed77d88fe9ab23257ff5a0348a7f72fe19dc294d8ea4b99ed", + "object_path": "lib/lean/Init/Data/Vector/OfFn.olean", + "object_sha256": "d114d78edb28295c40abd923a1c58cf5572d0bd0d269225217dc8c4025db9388", + "object_bytes": 170824, + "imports": [ + "Init.Data.Vector.Basic", + "Init.Data.Vector.Lemmas", + "Init.Data.Vector.Monadic", + "Init.Data.Array.OfFn" + ] + }, + { + "module": "Init.Data.Vector.Range", + "root": "lean", + "source_path": "src/lean/Init/Data/Vector/Range.lean", + "source_sha256": "f6fd25de70fec573b116d8980c40fa7c918f5947502d7e6c463407ceb1b197ad", + "object_path": "lib/lean/Init/Data/Vector/Range.olean", + "object_sha256": "fceeae9e5a7840055aa114104afcdbbc7ac202dc1b265e8f09b4e3630daa1d31", + "object_bytes": 136376, + "imports": [ + "Init.Data.Array.Basic", + "Init.Data.Vector.Basic", + "Init.Data.Vector.Lemmas", + "Init.Data.Vector.Zip", + "Init.Data.Vector.MapIdx", + "Init.Data.Array.Range" + ] + }, + { + "module": "Init.Data.Vector.Erase", + "root": "lean", + "source_path": "src/lean/Init/Data/Vector/Erase.lean", + "source_sha256": "3f0f9bae40867820d88cf40b61113b6e2d4b0f46dee998ba2577e7a65f4b0bb4", + "object_path": "lib/lean/Init/Data/Vector/Erase.olean", + "object_sha256": "8c6c4f1752ca0bd8f8db28e903ebf22baf17a79346513883457bd06de3da61c3", + "object_bytes": 72728, + "imports": [ + "Init.Data.Vector.Lemmas", + "Init.Data.Array.Erase" + ] + }, + { + "module": "Init.Data.Vector.InsertIdx", + "root": "lean", + "source_path": "src/lean/Init/Data/Vector/InsertIdx.lean", + "source_sha256": "cd1e7df37876a9d11d1b5e2ad5a2664396bd08e67b484f926a83153ae118b2dc", + "object_path": "lib/lean/Init/Data/Vector/InsertIdx.olean", + "object_sha256": "74698b279ad8e75a4f71f3227ac48f87f223978573d5d8a86e67ebdd7ec2101c", + "object_bytes": 75448, + "imports": [ + "Init.Data.Vector.Lemmas", + "Init.Data.Array.InsertIdx" + ] + }, + { + "module": "Init.Data.Vector.FinRange", + "root": "lean", + "source_path": "src/lean/Init/Data/Vector/FinRange.lean", + "source_sha256": "64e238c0c8ff9989fd1587e344a6cde9346a0adda63c2623ebbc66e2e28b3e13", + "object_path": "lib/lean/Init/Data/Vector/FinRange.olean", + "object_sha256": "376ac6b309bd8e8bdebfb9f215bfd3b215f243458ce4eb1f0d08352658f170cf", + "object_bytes": 39144, + "imports": [ + "Init.Data.Array.FinRange", + "Init.Data.Vector.OfFn" + ] + }, + { + "module": "Init.Data.Vector.Extract", + "root": "lean", + "source_path": "src/lean/Init/Data/Vector/Extract.lean", + "source_sha256": "515f9f6c22a0a04e5b0198164c01ab5dc444b60f9591479f4da9bf37d6e1bcd1", + "object_path": "lib/lean/Init/Data/Vector/Extract.olean", + "object_sha256": "3d1594266918f22e70f69f7aa604c4a8ef0faf3396ca291004a693f2dd998538", + "object_bytes": 106440, + "imports": [ + "Init.Data.Vector.Lemmas", + "Init.Data.Array.Extract" + ] + }, + { + "module": "Init.Data.Vector.Perm", + "root": "lean", + "source_path": "src/lean/Init/Data/Vector/Perm.lean", + "source_sha256": "e630245bb83756fc32729e5a0a51d1990750a43b7d21d1017913404b95994560", + "object_path": "lib/lean/Init/Data/Vector/Perm.olean", + "object_sha256": "8639e21a7748e288b78462acd32c5dbdf7fc7f5738bd059fcf93a5d9a128e3af", + "object_bytes": 132456, + "imports": [ + "Init.Data.Array.Basic", + "Init.Data.Array.Perm", + "Init.Data.Vector.Basic", + "Init.Data.Vector.Lemmas" + ] + }, + { + "module": "Init.Data.Vector.Find", + "root": "lean", + "source_path": "src/lean/Init/Data/Vector/Find.lean", + "source_sha256": "2e1cd3106436aa6f307259ca348b5f1f80af732b544e7bf3c2661e5ea9cfc539", + "object_path": "lib/lean/Init/Data/Vector/Find.olean", + "object_sha256": "f3e7e868d38e7a55bea2606ab795221854d546dbb15b5c166a4426a5e100f24d", + "object_bytes": 153272, + "imports": [ + "Init.Data.Array.Basic", + "Init.Data.Vector.Basic", + "Init.Data.Vector.Lemmas", + "Init.Data.Vector.Attach", + "Init.Data.Vector.Range", + "Init.Data.Array.Find" + ] + }, + { + "module": "Init.Data.Vector", + "root": "lean", + "source_path": "src/lean/Init/Data/Vector.lean", + "source_sha256": "3b90380f7a28ae9ba7161163c46a2cff4a5edb2e1d1abbb65e0cf89815995cc9", + "object_path": "lib/lean/Init/Data/Vector.olean", + "object_sha256": "8627b07586e4ba4fd7abe1fd87bfdb4419a5f6d2a1318a59d619a9e850885056", + "object_bytes": 19616, + "imports": [ + "Init.Data.Vector.Basic", + "Init.Data.Vector.Lemmas", + "Init.Data.Vector.Lex", + "Init.Data.Vector.MapIdx", + "Init.Data.Vector.Count", + "Init.Data.Vector.DecidableEq", + "Init.Data.Vector.Zip", + "Init.Data.Vector.OfFn", + "Init.Data.Vector.Range", + "Init.Data.Vector.Erase", + "Init.Data.Vector.Monadic", + "Init.Data.Vector.InsertIdx", + "Init.Data.Vector.FinRange", + "Init.Data.Vector.Extract", + "Init.Data.Vector.Perm", + "Init.Data.Vector.Find" + ] + }, + { + "module": "Init.Data", + "root": "lean", + "source_path": "src/lean/Init/Data.lean", + "source_sha256": "55f3aa570a13ce14c909c799b8804166b8ca3fc0c4cc24927452c88490513924", + "object_path": "lib/lean/Init/Data.olean", + "object_sha256": "63b0ef9072d90d7f4afd29ba0843449157faf27c92835f1d3fd9c3c18b69a3fb", + "object_bytes": 22144, + "imports": [ + "Init.Data.Basic", + "Init.Data.Nat", + "Init.Data.Bool", + "Init.Data.BitVec", + "Init.Data.Cast", + "Init.Data.Char", + "Init.Data.String", + "Init.Data.List", + "Init.Data.Int", + "Init.Data.Array", + "Init.Data.Array.Subarray.Split", + "Init.Data.ByteArray", + "Init.Data.FloatArray", + "Init.Data.Fin", + "Init.Data.UInt", + "Init.Data.SInt", + "Init.Data.Float", + "Init.Data.Float32", + "Init.Data.Option", + "Init.Data.Ord", + "Init.Data.Random", + "Init.Data.ToString", + "Init.Data.Range", + "Init.Data.Hashable", + "Init.Data.OfScientific", + "Init.Data.Format", + "Init.Data.Stream", + "Init.Data.Prod", + "Init.Data.AC", + "Init.Data.Queue", + "Init.Data.Sum", + "Init.Data.BEq", + "Init.Data.Subtype", + "Init.Data.ULift", + "Init.Data.PLift", + "Init.Data.Zero", + "Init.Data.NeZero", + "Init.Data.Function", + "Init.Data.RArray", + "Init.Data.Vector" + ] + }, + { + "module": "Init.System.Uri", + "root": "lean", + "source_path": "src/lean/Init/System/Uri.lean", + "source_sha256": "cc7331d52fc36298c7ea1ec9b4aac0e9e46cf8f710230c43570748a59dfafdbc", + "object_path": "lib/lean/Init/System/Uri.olean", + "object_sha256": "235bacd49c3a9a78253134c20bc7bb77957ea172f1316cab5d03bd67ef5a7d9f", + "object_bytes": 225656, + "imports": [ + "Init.Data.String.Extra", + "Init.Data.Nat.Linear", + "Init.System.FilePath" + ] + }, + { + "module": "Init.System.Mutex", + "root": "lean", + "source_path": "src/lean/Init/System/Mutex.lean", + "source_sha256": "947f3ede30a84d1292b668250d60a9cee527206af279b3bf6bd3f6b9e7834736", + "object_path": "lib/lean/Init/System/Mutex.olean", + "object_sha256": "d95d6f7097149bcd5718995ae301be0916bcafe0dc12b85097f5ff62ddfa06c0", + "object_bytes": 143496, + "imports": [ + "Init.System.IO", + "Init.Control.StateRef" + ] + }, + { + "module": "Init.System.Promise", + "root": "lean", + "source_path": "src/lean/Init/System/Promise.lean", + "source_sha256": "f3c159bc6766c90ea97fee75af59eb98f6ab8e2d5a049f5da7b0fc36a916279f", + "object_path": "lib/lean/Init/System/Promise.olean", + "object_sha256": "6aa995c0175d2817862e798264467dddf34be346c826e5a87d8f79e6b2e06eb5", + "object_bytes": 74496, + "imports": [ + "Init.System.IO" + ] + }, + { + "module": "Init.System", + "root": "lean", + "source_path": "src/lean/Init/System.lean", + "source_sha256": "822327f77f7b87134c660484db6d3a4a01bc0a05a35778aaa43e677ff42110bc", + "object_path": "lib/lean/Init/System.olean", + "object_sha256": "385cc0f6ab36e2a1b95369aee4f2cadd7947cb61b1143ab7dd6fb42ce5f31e36", + "object_bytes": 18384, + "imports": [ + "Init.System.IO", + "Init.System.Platform", + "Init.System.Uri", + "Init.System.Mutex", + "Init.System.Promise" + ] + }, + { + "module": "Init.Dynamic", + "root": "lean", + "source_path": "src/lean/Init/Dynamic.lean", + "source_sha256": "5bf48d86d63772901081ad746b2bf9c5ae1d09520c6ad4a9e1d92f338371c09c", + "object_path": "lib/lean/Init/Dynamic.olean", + "object_sha256": "c882de6edf5f25fddea3af77d40d7af7a16c74127340001f64d6c4f73c3f2f60", + "object_bytes": 55248, + "imports": [ + "Init.Core" + ] + }, + { + "module": "Init.ShareCommon", + "root": "lean", + "source_path": "src/lean/Init/ShareCommon.lean", + "source_sha256": "09750208f2c8917bdb9c9af2fc4fba559302a837c2bcc09678ec50ba4226c5fa", + "object_path": "lib/lean/Init/ShareCommon.olean", + "object_sha256": "343eecd2124d3b40fcb771f422d8a1a470ce3530a20aa3dc903b20b6150a5aee", + "object_bytes": 192320, + "imports": [ + "Init.Util", + "Init.Data.UInt.Basic" + ] + }, + { + "module": "Init.Hints", + "root": "lean", + "source_path": "src/lean/Init/Hints.lean", + "source_sha256": "7c83452db2cf806412a39e5b388c681f8e5cf5475960ea9212227f8509b264b2", + "object_path": "lib/lean/Init/Hints.olean", + "object_sha256": "873e51d76ad32241124c239ee4befff3480cfbd9bdcb5dde5f6b788bbf644528", + "object_bytes": 18792, + "imports": [ + "Init.NotationExtra" + ] + }, + { + "module": "Init.Guard", + "root": "lean", + "source_path": "src/lean/Init/Guard.lean", + "source_sha256": "eebc828c3f6891ab91c6342616174338a60a4559b0c9da7c4fe0fca0c35b3cc5", + "object_path": "lib/lean/Init/Guard.olean", + "object_sha256": "0ba39e25ac597d313c2afba3b45cc78ff22b24be01a7efd1a9c460f38393e54b", + "object_bytes": 140480, + "imports": [ + "Init.Tactics", + "Init.Conv", + "Init.NotationExtra" + ] + }, + { + "module": "Init.Simproc", + "root": "lean", + "source_path": "src/lean/Init/Simproc.lean", + "source_sha256": "47594f3ea99841e406af337521adba2f02cf94da79905bc75e1de519589220b8", + "object_path": "lib/lean/Init/Simproc.olean", + "object_sha256": "739bec2653f473115a64208963bd3275cc812ea8387b1e38641cf271fdaa3430", + "object_bytes": 510512, + "imports": [ + "Init.NotationExtra" + ] + }, + { + "module": "Init.SizeOfLemmas", + "root": "lean", + "source_path": "src/lean/Init/SizeOfLemmas.lean", + "source_sha256": "e53dcd9b07d68382339bfc6168b9172a5d824d0e015b82b9c1b2d44b6bb19374", + "object_path": "lib/lean/Init/SizeOfLemmas.olean", + "object_sha256": "0101f49be0f8a2fd02f14fdf725173f27d00359d2c4d77d08f0a513c06ff7410", + "object_bytes": 36248, + "imports": [ + "Init.Data.Char.Basic", + "Init.Meta", + "Init.SizeOf", + "Init.Data.Nat.Linear" + ] + }, + { + "module": "Init.MacroTrace", + "root": "lean", + "source_path": "src/lean/Init/MacroTrace.lean", + "source_sha256": "5f61fbc3889b2fae0c4aae48da06ad742bc8db39769b93d9df6e31901986c424", + "object_path": "lib/lean/Init/MacroTrace.olean", + "object_sha256": "3057d2e4ce4ea116fe17cb9b9c85c02b0daab1447ad929963d74c884948545c4", + "object_bytes": 84840, + "imports": [ + "Init.Data.ToString.Macro", + "Init.Meta" + ] + }, + { + "module": "Init.Grind.Norm", + "root": "lean", + "source_path": "src/lean/Init/Grind/Norm.lean", + "source_sha256": "652ed44a2dc96e9afbf79d210a46774ee6adbf3685ee8c6683e6381421311137", + "object_path": "lib/lean/Init/Grind/Norm.olean", + "object_sha256": "e6aa0a3de6ffb9956e0f65d033d3fb08677bb5fb1d90bfb88e9aa92734dfa264", + "object_bytes": 109168, + "imports": [ + "Init.SimpLemmas", + "Init.PropLemmas", + "Init.Classical", + "Init.ByCases", + "Init.Data.Int.Linear", + "Init.Data.Int.Pow" + ] + }, + { + "module": "Init.Grind.Util", + "root": "lean", + "source_path": "src/lean/Init/Grind/Util.lean", + "source_sha256": "380d002aec06999f41e1338ec333162c0f8c0a875d314b8ed9ec64620c6ba93b", + "object_path": "lib/lean/Init/Grind/Util.olean", + "object_sha256": "2284e78674dafa5df89ec8ccb67e7101f46231456e977fa80768102339f00427", + "object_bytes": 67672, + "imports": [ + "Init.Core", + "Init.Classical" + ] + }, + { + "module": "Init.Grind.Lemmas", + "root": "lean", + "source_path": "src/lean/Init/Grind/Lemmas.lean", + "source_sha256": "ed4c9c1ecb0e7a585f23b5f437c35bcf583efae4f8519a586bfd5e038f3f342e", + "object_path": "lib/lean/Init/Grind/Lemmas.olean", + "object_sha256": "5cf0fee1349075400865e8336af82da7290a7bd69053a8916fbbfa5c57786bd5", + "object_bytes": 65520, + "imports": [ + "Init.Core", + "Init.SimpLemmas", + "Init.Classical", + "Init.ByCases", + "Init.Grind.Util" + ] + }, + { + "module": "Init.Grind.Cases", + "root": "lean", + "source_path": "src/lean/Init/Grind/Cases.lean", + "source_sha256": "d74d30f7311abb7a11783c944034ebe9b42bfbaf4f0e6f14141535e474e81641", + "object_path": "lib/lean/Init/Grind/Cases.olean", + "object_sha256": "550c166eaa5d14f208145aa0808175d9575095600fb963dbdee223411c2d6ce0", + "object_bytes": 19128, + "imports": [ + "Init.Core", + "Init.Grind.Tactics" + ] + }, + { + "module": "Init.Grind.Propagator", + "root": "lean", + "source_path": "src/lean/Init/Grind/Propagator.lean", + "source_sha256": "b56aee01e1914c1c4d7820bd4dbec9bbee36f7f0dc436248557ac28993d49f4e", + "object_path": "lib/lean/Init/Grind/Propagator.olean", + "object_sha256": "7b8d904d40808462b59d8ed444de55f7870d003021f9c466141264d1a5fae9cf", + "object_bytes": 144016, + "imports": [ + "Init.NotationExtra" + ] + }, + { + "module": "Init.Grind.Offset", + "root": "lean", + "source_path": "src/lean/Init/Grind/Offset.lean", + "source_sha256": "01347505f42925b939645f0cd87136bc87201a19093205541f999be0b7e54ae5", + "object_path": "lib/lean/Init/Grind/Offset.olean", + "object_sha256": "d7a8ba581a44e6fdc9b7bb3eff448003f834d054a49adc56e51e22559490e9b0", + "object_bytes": 65488, + "imports": [ + "Init.Core", + "Init.Omega" + ] + }, + { + "module": "Init.Grind.PP", + "root": "lean", + "source_path": "src/lean/Init/Grind/PP.lean", + "source_sha256": "8a3a277811bc974383769ad23a095f4bf1fe82fd3aa44b6a50ec1136f825d4af", + "object_path": "lib/lean/Init/Grind/PP.olean", + "object_sha256": "0b85a08f3ee327bee753fd31170b9fa627ef291da2863299912f591af324c0ad", + "object_bytes": 58776, + "imports": [ + "Init.NotationExtra" + ] + }, + { + "module": "Init.Grind.Module.Basic", + "root": "lean", + "source_path": "src/lean/Init/Grind/Module/Basic.lean", + "source_sha256": "d16d96e03ab49341df1d2861796bc73866387b72b6bdc6d13a14ff7c461832ca", + "object_path": "lib/lean/Init/Grind/Module/Basic.olean", + "object_sha256": "348370abac0b58bda471b8f553d78b77da93cfbeee6c1b001f26ca0155b7e35d", + "object_bytes": 213056, + "imports": [ + "Init.Data.Int.Order" + ] + }, + { + "module": "Init.Grind.CommRing.Basic", + "root": "lean", + "source_path": "src/lean/Init/Grind/CommRing/Basic.lean", + "source_sha256": "043bd19bc77bbf8d03835bb7d33dd5c2dcf444a79d604e7509ccd98764f9dc5e", + "object_path": "lib/lean/Init/Grind/CommRing/Basic.olean", + "object_sha256": "81bd817a87a04a09fdf5743069c3a237c081daf495f4cb44089a3666d38a0c9f", + "object_bytes": 486552, + "imports": [ + "Init.Data.Zero", + "Init.Data.Int.DivMod.Lemmas", + "Init.Data.Int.Pow", + "Init.TacticsExtra", + "Init.Grind.Module.Basic" + ] + }, + { + "module": "Init.Grind.CommRing.Int", + "root": "lean", + "source_path": "src/lean/Init/Grind/CommRing/Int.lean", + "source_sha256": "202e58ceb1b553832e2f9b5541363d645ab8d2c9e05f289c1d1a5102891b949f", + "object_path": "lib/lean/Init/Grind/CommRing/Int.olean", + "object_sha256": "df1738e954ce60f0550309094a426721700c0e746984d2bbbd939f03df4f6fd1", + "object_bytes": 46848, + "imports": [ + "Init.Grind.CommRing.Basic", + "Init.Data.Int.Lemmas" + ] + }, + { + "module": "Init.Grind.CommRing.UInt", + "root": "lean", + "source_path": "src/lean/Init/Grind/CommRing/UInt.lean", + "source_sha256": "317e638f13347aef6d9cc1289f4c60656aca923f3545d8ba05c8b7c2e52aefd1", + "object_path": "lib/lean/Init/Grind/CommRing/UInt.olean", + "object_sha256": "a0b7fe7fd7bca54b662fefbecd0b6ab37dd8bc26befb82eecf2cc10bab1e3741", + "object_bytes": 145640, + "imports": [ + "Init.Grind.CommRing.Basic", + "Init.Data.UInt.Basic", + "Init.Data.UInt.Lemmas" + ] + }, + { + "module": "Init.Grind.CommRing.SInt", + "root": "lean", + "source_path": "src/lean/Init/Grind/CommRing/SInt.lean", + "source_sha256": "7c87168b6f2ad692042fc14af07cfec2a302204f863292b61b2881fd53ec0cb6", + "object_path": "lib/lean/Init/Grind/CommRing/SInt.olean", + "object_sha256": "7ba0714f44ee79dd2a2ec503322a8745b3fbf75f6518ebd0cc1b34ddc5a8b1a7", + "object_bytes": 141864, + "imports": [ + "Init.Grind.CommRing.Basic", + "Init.Data.BitVec.Basic", + "Init.Data.SInt.Basic", + "Init.Data.SInt.Lemmas" + ] + }, + { + "module": "Init.Grind.CommRing.Fin", + "root": "lean", + "source_path": "src/lean/Init/Grind/CommRing/Fin.lean", + "source_sha256": "b7af7b2889c055ed574fd46ad0cc4996a69448c0850361ae712e7b12647f3842", + "object_path": "lib/lean/Init/Grind/CommRing/Fin.olean", + "object_sha256": "0734c8e5ad4c3c431c7162ee6a00fbc85fb796a3609765999d7936c2312cb6d2", + "object_bytes": 79696, + "imports": [ + "Init.Data.Zero", + "Init.Grind.CommRing.Basic", + "Init.Data.Fin.Lemmas" + ] + }, + { + "module": "Init.Grind.CommRing.BitVec", + "root": "lean", + "source_path": "src/lean/Init/Grind/CommRing/BitVec.lean", + "source_sha256": "9dbb6de7ceda08ae8de38e0da5b1c6ca4b2cbd3fa74695c12782a4490aa53b12", + "object_path": "lib/lean/Init/Grind/CommRing/BitVec.olean", + "object_sha256": "51fd22832949b3376b505477da8d37456d0ca264a674126652a8944e68096b45", + "object_bytes": 53464, + "imports": [ + "Init.Grind.CommRing.Basic", + "Init.Data.BitVec.Basic", + "Init.Data.BitVec.Lemmas" + ] + }, + { + "module": "Init.Grind.CommRing.Poly", + "root": "lean", + "source_path": "src/lean/Init/Grind/CommRing/Poly.lean", + "source_sha256": "c7a63490d735073e90649f147ab56f47cb27a1c59a8fa9a7a82755cf69f1c06a", + "object_path": "lib/lean/Init/Grind/CommRing/Poly.olean", + "object_sha256": "733f84dcba97d46f178ba95eaa3032cdab06983293b4ef4d8afd7b6c7ad16891", + "object_bytes": 1669800, + "imports": [ + "Init.Data.Nat.Lemmas", + "Init.Data.Hashable", + "Init.Data.Ord", + "Init.Data.RArray", + "Init.Grind.CommRing.Basic" + ] + }, + { + "module": "Init.Grind.CommRing.Field", + "root": "lean", + "source_path": "src/lean/Init/Grind/CommRing/Field.lean", + "source_sha256": "5310440df040149332892ed491e2badbcf81592891bdbb8eb4a7e9bb1815eaba", + "object_path": "lib/lean/Init/Grind/CommRing/Field.olean", + "object_sha256": "1fa14ac2ee965e6c35dc2958402dbf05d8f6612cc4bdd7c2ae389ed9f33415e5", + "object_bytes": 99528, + "imports": [ + "Init.Grind.CommRing.Basic" + ] + }, + { + "module": "Init.Grind.CommRing", + "root": "lean", + "source_path": "src/lean/Init/Grind/CommRing.lean", + "source_sha256": "b44f5d55bfcd8ca5e9255cde273d69ac127385fd7e4184e4aa93189c63764755", + "object_path": "lib/lean/Init/Grind/CommRing.olean", + "object_sha256": "07b28d80a250833c1f5d89241f084935206d0e0ef0a5a9073ea83998810a1158", + "object_bytes": 18728, + "imports": [ + "Init.Grind.CommRing.Basic", + "Init.Grind.CommRing.Int", + "Init.Grind.CommRing.UInt", + "Init.Grind.CommRing.SInt", + "Init.Grind.CommRing.Fin", + "Init.Grind.CommRing.BitVec", + "Init.Grind.CommRing.Poly", + "Init.Grind.CommRing.Field" + ] + }, + { + "module": "Init.Grind.Module", + "root": "lean", + "source_path": "src/lean/Init/Grind/Module.lean", + "source_sha256": "be14a89ed6f87192a2e31bcb3782e6d76fdefe17683f51d21a5b4938230d1ced", + "object_path": "lib/lean/Init/Grind/Module.olean", + "object_sha256": "a44f027cffcae21a8b9ca14572d290a8473a805bd7ea114ef45b910b1bea47f0", + "object_bytes": 17992, + "imports": [ + "Init.Grind.Module.Basic" + ] + }, + { + "module": "Init.Grind.Ordered.Order", + "root": "lean", + "source_path": "src/lean/Init/Grind/Ordered/Order.lean", + "source_sha256": "7e3f1450ff0e1eef6fc67e1b46fcc825ddf301f248440871c8433ff8d0f38306", + "object_path": "lib/lean/Init/Grind/Ordered/Order.olean", + "object_sha256": "103a74c6efe3a73ca84256343bdd368512655083ca043a5364b0fbda5d348a45", + "object_bytes": 123200, + "imports": [ + "Init.Data.Int.Order" + ] + }, + { + "module": "Init.Grind.Ordered.Module", + "root": "lean", + "source_path": "src/lean/Init/Grind/Ordered/Module.lean", + "source_sha256": "d5bbf4060f7522904ed92d0b376a6bf0399729d08f33e12900136bfce7afde34", + "object_path": "lib/lean/Init/Grind/Ordered/Module.olean", + "object_sha256": "432f125887c0f3cf17e7d6996c036296c96f2f9c91e6079623b3d5b00d7de15a", + "object_bytes": 73368, + "imports": [ + "Init.Data.Int.Order", + "Init.Grind.Module.Basic", + "Init.Grind.Ordered.Order" + ] + }, + { + "module": "Init.Grind.Ordered.Ring", + "root": "lean", + "source_path": "src/lean/Init/Grind/Ordered/Ring.lean", + "source_sha256": "937fa156a1b879eb86c335994d82707ea9a8b927c66f3f471a38d38c9d523529", + "object_path": "lib/lean/Init/Grind/Ordered/Ring.olean", + "object_sha256": "cc2ddeca27dd89ea8440cd87811cafc9516f0925e51fba3e7436d74cd9c57d2b", + "object_bytes": 93504, + "imports": [ + "Init.Grind.CommRing.Basic", + "Init.Grind.Ordered.Module" + ] + }, + { + "module": "Init.Grind.Ordered.Field", + "root": "lean", + "source_path": "src/lean/Init/Grind/Ordered/Field.lean", + "source_sha256": "86eb7baaa906e9ffaab7f1ff70a918611d9e36b36f7f9bd22a971704f8d64bd8", + "object_path": "lib/lean/Init/Grind/Ordered/Field.olean", + "object_sha256": "c7826c17433406ff32dd736bd52d656a2413ffd63c9139e04b4f1c6dc7c1214c", + "object_bytes": 61456, + "imports": [ + "Init.Grind.CommRing.Field", + "Init.Grind.Ordered.Ring" + ] + }, + { + "module": "Init.Grind.Ordered.Int", + "root": "lean", + "source_path": "src/lean/Init/Grind/Ordered/Int.lean", + "source_sha256": "f3b8e573f938da8a4b4c2e8edc82105758e42728624e44e4d3783dc522d5c38d", + "object_path": "lib/lean/Init/Grind/Ordered/Int.olean", + "object_sha256": "880655b29d8f5706f6263fe10152dd90fc1a890ab8761da2d1c144c03827bbd0", + "object_bytes": 32824, + "imports": [ + "Init.Grind.Ordered.Ring", + "Init.Grind.CommRing.Int", + "Init.Omega" + ] + }, + { + "module": "Init.Grind.Ordered", + "root": "lean", + "source_path": "src/lean/Init/Grind/Ordered.lean", + "source_sha256": "ac757a7934d8e7a975e2a2cab3651ccbb7f78cd4b149ec27dc74c8efe051c3c5", + "object_path": "lib/lean/Init/Grind/Ordered.olean", + "object_sha256": "ef99356a0457852a27a11844a18d628418da7748276f241ea9fbb9145d23c43b", + "object_bytes": 18408, + "imports": [ + "Init.Grind.Ordered.Order", + "Init.Grind.Ordered.Module", + "Init.Grind.Ordered.Ring", + "Init.Grind.Ordered.Field", + "Init.Grind.Ordered.Int" + ] + }, + { + "module": "Init.Grind.Ext", + "root": "lean", + "source_path": "src/lean/Init/Grind/Ext.lean", + "source_sha256": "c0eef452c26d315b3eb66f807f38d29a9ee65e4b8661ef94540519fbcb04167b", + "object_path": "lib/lean/Init/Grind/Ext.olean", + "object_sha256": "f78e936b3b684880b42545253d9534ee1d2387805554ed29ca4ddd53fd4047b4", + "object_bytes": 18488, + "imports": [ + "Init.Ext", + "Init.Grind.Tactics" + ] + }, + { + "module": "Init.Grind", + "root": "lean", + "source_path": "src/lean/Init/Grind.lean", + "source_sha256": "33e8c8dffe2dec9cb75e4ea79248a31d64acc83af4d15b0ef05f1a4cae865859", + "object_path": "lib/lean/Init/Grind.olean", + "object_sha256": "e9ed2844aa976ceb500ba0511fca84f9f7479bff2668b21d10ecf20a9809918f", + "object_bytes": 19040, + "imports": [ + "Init.Grind.Norm", + "Init.Grind.Tactics", + "Init.Grind.Lemmas", + "Init.Grind.Cases", + "Init.Grind.Propagator", + "Init.Grind.Util", + "Init.Grind.Offset", + "Init.Grind.PP", + "Init.Grind.CommRing", + "Init.Grind.Module", + "Init.Grind.Ordered", + "Init.Grind.Ext" + ] + }, + { + "module": "Init.Internal.Order.Basic", + "root": "lean", + "source_path": "src/lean/Init/Internal/Order/Basic.lean", + "source_sha256": "d9189c7fe6f8333b89ff731d8ff1f38e1e106f3ca9ee4d756ab6732ed8c0f44e", + "object_path": "lib/lean/Init/Internal/Order/Basic.olean", + "object_sha256": "f9153acb79234c0c8867078f7f07f8024a20c07052d4af0daf7c7770ba38f991", + "object_bytes": 461416, + "imports": [ + "Init.ByCases", + "Init.RCases", + "Init.Control.Except" + ] + }, + { + "module": "Init.Internal.Order.Lemmas", + "root": "lean", + "source_path": "src/lean/Init/Internal/Order/Lemmas.lean", + "source_sha256": "f59120b37f9c00d07e67d4213c6c16e3be1f242a05d0fa9295992f5db4b11518", + "object_path": "lib/lean/Init/Internal/Order/Lemmas.olean", + "object_sha256": "4aeea922908513927144b89e0dfe421181bdd0536378249a93bc5413edd7a970", + "object_bytes": 288736, + "imports": [ + "Init.Data.List.Control", + "Init.Data.Option.Basic", + "Init.Data.Array.Basic", + "Init.Internal.Order.Basic" + ] + }, + { + "module": "Init.Internal.Order.Tactic", + "root": "lean", + "source_path": "src/lean/Init/Internal/Order/Tactic.lean", + "source_sha256": "c312b6714091f3d456713bc4b82071130e7218c4e01c4d488c38db5ca97762db", + "object_path": "lib/lean/Init/Internal/Order/Tactic.olean", + "object_sha256": "77b68a7d8e546b4bbae6f10da2278424e4208322d8881eb172cfa9523422fd03", + "object_bytes": 25424, + "imports": [ + "Init.Notation" + ] + }, + { + "module": "Init.Internal.Order", + "root": "lean", + "source_path": "src/lean/Init/Internal/Order.lean", + "source_sha256": "b69b9d453772911035f7a81d1d0bd9192ccd424966108d2f0b831aa622ff26a0", + "object_path": "lib/lean/Init/Internal/Order.olean", + "object_sha256": "6fc401917b649c11f78546197bd902127f6a52f4040ff033ebf9953a1f75b8c0", + "object_bytes": 18208, + "imports": [ + "Init.Internal.Order.Basic", + "Init.Internal.Order.Lemmas", + "Init.Internal.Order.Tactic" + ] + }, + { + "module": "Init.Internal", + "root": "lean", + "source_path": "src/lean/Init/Internal.lean", + "source_sha256": "9ef7f1bd047d4de3f46e67b285edddc33527ae5720613845b5ec31470b3b03ee", + "object_path": "lib/lean/Init/Internal.olean", + "object_sha256": "dcec98a350332bf022636f541675f175a7b9f2d29cbfdd5ac5ebd11762e5014c", + "object_bytes": 17968, + "imports": [ + "Init.Internal.Order" + ] + }, + { + "module": "Init.Try", + "root": "lean", + "source_path": "src/lean/Init/Try.lean", + "source_sha256": "31da160e55dcfb1e42ef873a3bc01cb37242c8bf5efbc9e1ba059dc1ca9ee4e9", + "object_path": "lib/lean/Init/Try.olean", + "object_sha256": "1be03ecef9666f136242a3ede3133719f6b077351d8fc6ea2fb7f00256f402ba", + "object_bytes": 90272, + "imports": [ + "Init.Tactics" + ] + }, + { + "module": "Init.Task", + "root": "lean", + "source_path": "src/lean/Init/Task.lean", + "source_sha256": "dabe74a4670f9a365fa8c0c6fdd29b83bba52bec2b4885262a784f8d51ed9ff6", + "object_path": "lib/lean/Init/Task.olean", + "object_sha256": "cb25034ccb0c3c9bea425d88d36d3a316344f140c626169bda11a1a8cb09307e", + "object_bytes": 52856, + "imports": [ + "Init.Core", + "Init.Data.List.Basic" + ] + }, + { + "module": "Init", + "root": "lean", + "source_path": "src/lean/Init.lean", + "source_sha256": "73f60c52e860b69f8fc636ad1b95a62fa6678de49c38f9d59b77a8ef45a5f90f", + "object_path": "lib/lean/Init.olean", + "object_sha256": "986cb78b8abe89c1eb21703cc912053875d2d18bc3e8a8249140c7f808505172", + "object_bytes": 21504, + "imports": [ + "Init.Prelude", + "Init.Notation", + "Init.Tactics", + "Init.TacticsExtra", + "Init.ByCases", + "Init.RCases", + "Init.Core", + "Init.Control", + "Init.Data.Basic", + "Init.WF", + "Init.WFTactics", + "Init.Data", + "Init.System", + "Init.Util", + "Init.Dynamic", + "Init.ShareCommon", + "Init.MetaTypes", + "Init.Meta", + "Init.NotationExtra", + "Init.SimpLemmas", + "Init.PropLemmas", + "Init.Hints", + "Init.Conv", + "Init.Guard", + "Init.Simproc", + "Init.SizeOfLemmas", + "Init.BinderPredicates", + "Init.Ext", + "Init.Omega", + "Init.MacroTrace", + "Init.Grind", + "Init.While", + "Init.Syntax", + "Init.Internal", + "Init.Try", + "Init.BinderNameHint", + "Init.Task" + ] + }, + { + "module": "Lean.Data.AssocList", + "root": "lean", + "source_path": "src/lean/Lean/Data/AssocList.lean", + "source_sha256": "5f3289e70cbad43c6b59be8b18ca9ce803792df55f3e7503d2553cba156907ca", + "object_path": "lib/lean/Lean/Data/AssocList.olean", + "object_sha256": "b71ebad58e6a2c92f798bfc37444fdbbe695699b651f70fae249929f001cfd12", + "object_bytes": 306000, + "imports": [ + "Init.Control.Id", + "Init.Data.List.Impl" + ] + }, + { + "module": "Lean.ImportingFlag", + "root": "lean", + "source_path": "src/lean/Lean/ImportingFlag.lean", + "source_sha256": "8d8339a0c547eb2955b18c95baafa1dccb699c95941294858570b293a598f9f8", + "object_path": "lib/lean/Lean/ImportingFlag.olean", + "object_sha256": "cb8219c144f16e16793177c6a274fb5dea2a4448a6937ced57e520a4847f85fe", + "object_bytes": 60952, + "imports": [ + "Init.System.IO" + ] + }, + { + "module": "Lean.Data.KVMap", + "root": "lean", + "source_path": "src/lean/Lean/Data/KVMap.lean", + "source_sha256": "a88e526eff058570742a123019ec53b3b8a9e33181c82027f4c88a96e9027902", + "object_path": "lib/lean/Lean/Data/KVMap.olean", + "object_sha256": "257bb19bc59309302ec9dbe8b07eebe056b8be109a1a3ac8af61897699393fd8", + "object_bytes": 605680, + "imports": [ + "Init.Data.List.Impl", + "Init.Data.Format.Syntax" + ] + }, + { + "module": "Std.Data.DHashMap.Internal.AssocList.Basic", + "root": "lean", + "source_path": "src/lean/Std/Data/DHashMap/Internal/AssocList/Basic.lean", + "source_sha256": "2bd7561e386ad5f9cf3c35647bc567723c630e57750946a2af3dd8e5428739fb", + "object_path": "lib/lean/Std/Data/DHashMap/Internal/AssocList/Basic.olean", + "object_sha256": "9b6e69772a3beee5ca320142e5339f69a5536bd7bccba5c772b02ae82d4928bc", + "object_bytes": 552392, + "imports": [ + "Init.NotationExtra" + ] + }, + { + "module": "Std.Data.DHashMap.RawDef", + "root": "lean", + "source_path": "src/lean/Std/Data/DHashMap/RawDef.lean", + "source_sha256": "b548192fb5b340fca23f8a786b4ad54f6ac5941fddeb8c68cf8fc8c56341821c", + "object_path": "lib/lean/Std/Data/DHashMap/RawDef.olean", + "object_sha256": "6c9828955533b813587a808798d4de7e49fb1f3d4566753996648335d76771f8", + "object_bytes": 60760, + "imports": [ + "Std.Data.DHashMap.Internal.AssocList.Basic" + ] + }, + { + "module": "Std.Data.Internal.List.Defs", + "root": "lean", + "source_path": "src/lean/Std/Data/Internal/List/Defs.lean", + "source_sha256": "c216e8ae1469ecf097d4559817a843222113d35be1620885e041407ceb54d4e7", + "object_path": "lib/lean/Std/Data/Internal/List/Defs.olean", + "object_sha256": "a5a0ec35232d388131fc60a416e4450bb31f1436c452378f2e9848b8faaf3a04", + "object_bytes": 75904, + "imports": [ + "Init.BinderPredicates" + ] + }, + { + "module": "Std.Data.DHashMap.Internal.Index", + "root": "lean", + "source_path": "src/lean/Std/Data/DHashMap/Internal/Index.lean", + "source_sha256": "7ad08ee68438132a16746bb99e0a08461f46da9ac669ed9c07e6cfb2eebab401", + "object_path": "lib/lean/Std/Data/DHashMap/Internal/Index.olean", + "object_sha256": "45c55cf9020018e667aa11668d0a9b213eb2e0623371e963ec576781c5208cdb", + "object_bytes": 53008, + "imports": [ + "Init.Data.UInt.Lemmas", + "Init.Data.UInt.Bitwise" + ] + }, + { + "module": "Std.Data.DHashMap.Internal.Defs", + "root": "lean", + "source_path": "src/lean/Std/Data/DHashMap/Internal/Defs.lean", + "source_sha256": "3e5645ee3aaf55a8546a21017c10300823831ff1ad45694782fdd3d6a98cc290", + "object_path": "lib/lean/Std/Data/DHashMap/Internal/Defs.olean", + "object_sha256": "8ac0da7e9652f694cd168ce715c0bf55ba052c8c373f70f5dc8c82efdda6c33a", + "object_bytes": 1126576, + "imports": [ + "Init.Data.Array.Lemmas", + "Std.Data.DHashMap.RawDef", + "Std.Data.Internal.List.Defs", + "Std.Data.DHashMap.Internal.Index" + ] + }, + { + "module": "Std.Data.DHashMap.Raw", + "root": "lean", + "source_path": "src/lean/Std/Data/DHashMap/Raw.lean", + "source_sha256": "60424cfabefd636d6cc8af59d26f0f35d8152fc375a5bdc5b9433e420569eb6e", + "object_path": "lib/lean/Std/Data/DHashMap/Raw.olean", + "object_sha256": "0fcddd76ea099500cc2cbeae8a4b2a4360831dc43636ad6bfb56e4af724a4aa8", + "object_bytes": 2123952, + "imports": [ + "Init.Data.BEq", + "Init.Data.Hashable", + "Std.Data.DHashMap.Internal.Defs" + ] + }, + { + "module": "Std.Data.DHashMap.Basic", + "root": "lean", + "source_path": "src/lean/Std/Data/DHashMap/Basic.lean", + "source_sha256": "a328c316fa37351c7270a118d96b6deb88688b2577be8e87d3b505a435cf07f2", + "object_path": "lib/lean/Std/Data/DHashMap/Basic.olean", + "object_sha256": "3a298c6f30f9fd3f784086263f80963945e9ac253017305ae2ead5c2bab01bab", + "object_bytes": 1566560, + "imports": [ + "Std.Data.DHashMap.Raw" + ] + }, + { + "module": "Std.Data.HashMap.Basic", + "root": "lean", + "source_path": "src/lean/Std/Data/HashMap/Basic.lean", + "source_sha256": "aa00e31cac9d626bfd0c71181d169ca3e91e3c553ca4852e30d90b8524d4ea1e", + "object_path": "lib/lean/Std/Data/HashMap/Basic.olean", + "object_sha256": "f47ca53042a41a8da6ef2271e6d7c188953a0db8ab369704ae39a90692b51e04", + "object_bytes": 1445064, + "imports": [ + "Std.Data.DHashMap.Basic" + ] + }, + { + "module": "Std.Data.HashSet.Basic", + "root": "lean", + "source_path": "src/lean/Std/Data/HashSet/Basic.lean", + "source_sha256": "dec6360ea1bba5ed99e6898cc387413ae4f3fe1e733244ae508c50f646cd4d08", + "object_path": "lib/lean/Std/Data/HashSet/Basic.olean", + "object_sha256": "b4b3a817c48aa88177a565b4392e1c2c4a1b3f709444ca61e253b91f39fc00f4", + "object_bytes": 912232, + "imports": [ + "Std.Data.HashMap.Basic" + ] + }, + { + "module": "Lean.Data.RBMap", + "root": "lean", + "source_path": "src/lean/Lean/Data/RBMap.lean", + "source_sha256": "0e3e95e34cfbcb2b1badba9e6ea7e05674fe5b10aabd114ee09ab1e0291feabb", + "object_path": "lib/lean/Lean/Data/RBMap.olean", + "object_sha256": "23d5ced7344c627d6238d75ebd0e89ef353924c738810b94b802d02cb2fb7eac", + "object_bytes": 2160240, + "imports": [ + "Init.Data.Ord", + "Init.Data.Nat.Linear" + ] + }, + { + "module": "Lean.Data.RBTree", + "root": "lean", + "source_path": "src/lean/Lean/Data/RBTree.lean", + "source_sha256": "62357d6da60e581f242c54b5eea8ddad963647e4b866858d2d11091912d868b3", + "object_path": "lib/lean/Lean/Data/RBTree.olean", + "object_sha256": "8b992a725ddef3eae3c548d6bf1d65373bc525eb217ec99666eb5803a8fafc08", + "object_bytes": 275016, + "imports": [ + "Lean.Data.RBMap" + ] + }, + { + "module": "Lean.Data.PersistentHashMap", + "root": "lean", + "source_path": "src/lean/Lean/Data/PersistentHashMap.lean", + "source_sha256": "410128e4397ce090898baa2a88ee1f879443d269c561b48fdf00185f6e9bcb82", + "object_path": "lib/lean/Lean/Data/PersistentHashMap.olean", + "object_sha256": "7206d9ea0d3ab8011304ae061e37d21f4bd0cc910dd939aee60a379a41542edc", + "object_bytes": 1072520, + "imports": [ + "Init.Data.Array.BasicAux", + "Init.Data.ToString.Macro", + "Init.Data.UInt.Basic" + ] + }, + { + "module": "Lean.Data.SMap", + "root": "lean", + "source_path": "src/lean/Lean/Data/SMap.lean", + "source_sha256": "577d215482056216308a293c3926e515e0bcf2e5f077f932fc3d5a5e78ae28c9", + "object_path": "lib/lean/Lean/Data/SMap.olean", + "object_sha256": "26255bb87fb25cd9d3f7a8fce725f641f7fb025bb0bb2bb09f5ae9df0db6427e", + "object_bytes": 605232, + "imports": [ + "Std.Data.HashMap.Basic", + "Lean.Data.PersistentHashMap" + ] + }, + { + "module": "Lean.Data.SSet", + "root": "lean", + "source_path": "src/lean/Lean/Data/SSet.lean", + "source_sha256": "7519f7ebd88c302b0ef85d608b18e006bb873cc426e43ca08947c0dadc423751", + "object_path": "lib/lean/Lean/Data/SSet.olean", + "object_sha256": "77ea1b23ac27b3ade9db87f2ab8bba56145b1944a0bdb30f7dae408407e93550", + "object_bytes": 140984, + "imports": [ + "Lean.Data.SMap" + ] + }, + { + "module": "Lean.Data.Name", + "root": "lean", + "source_path": "src/lean/Lean/Data/Name.lean", + "source_sha256": "7efd9002ec2931e95af88e33b247729a6933bb0f2cde6b26d1349cb43627dc2a", + "object_path": "lib/lean/Lean/Data/Name.olean", + "object_sha256": "15d92c4fd07c70b3257967e9ade64f53fa66493739405f9ce637784078f8e8a0", + "object_bytes": 273680, + "imports": [ + "Init.Data.Ord" + ] + }, + { + "module": "Lean.Data.NameMap", + "root": "lean", + "source_path": "src/lean/Lean/Data/NameMap.lean", + "source_sha256": "7dc0d03ba6f414afe58e59c5752087fe5e29926dbc3a522c96e124783b59600f", + "object_path": "lib/lean/Lean/Data/NameMap.olean", + "object_sha256": "15cfc354d27d9842a4cb3075db5816da2fe06893faa53a399b6a9e521bd917e9", + "object_bytes": 394376, + "imports": [ + "Std.Data.HashSet.Basic", + "Lean.Data.RBMap", + "Lean.Data.RBTree", + "Lean.Data.SSet", + "Lean.Data.Name" + ] + }, + { + "module": "Lean.Data.Options", + "root": "lean", + "source_path": "src/lean/Lean/Data/Options.lean", + "source_sha256": "f84a0d2e03af03fb10cb9f7c58adf6b96057b6fa18e120e674f5ea801102642c", + "object_path": "lib/lean/Lean/Data/Options.olean", + "object_sha256": "e4853c1586a07c73dc5abef7021a44d5174362487acb77b1a13eeab13b9a42af", + "object_bytes": 459448, + "imports": [ + "Lean.ImportingFlag", + "Lean.Data.KVMap", + "Lean.Data.NameMap" + ] + }, + { + "module": "Lean.Data.Format", + "root": "lean", + "source_path": "src/lean/Lean/Data/Format.lean", + "source_sha256": "b3d7476b7f5ef618fa8fbd4c4a0b3d9fe4e7c8c495bb6794a7c9c0d5ce4d49c6", + "object_path": "lib/lean/Lean/Data/Format.olean", + "object_sha256": "7f93039c0ff6ff0fe146f71c4ddd6c330a552a6966f6486fbb9b0e863a36bfe6", + "object_bytes": 383808, + "imports": [ + "Lean.Data.Options" + ] + }, + { + "module": "Lean.Data.Json.Basic", + "root": "lean", + "source_path": "src/lean/Lean/Data/Json/Basic.lean", + "source_sha256": "d74f4bd84007dfb67fb7961bed67b980585e5f65eb6ef1fe4ed0fbd2b1ff2950", + "object_path": "lib/lean/Lean/Data/Json/Basic.olean", + "object_sha256": "141e100f2ce229002f8f13bb4fd4dbab52baccea0695d0e5e120bec695a4930b", + "object_bytes": 814640, + "imports": [ + "Init.Data.Range", + "Init.Data.OfScientific", + "Init.Data.Hashable", + "Lean.Data.RBMap", + "Init.Data.ToString.Macro" + ] + }, + { + "module": "Std.Internal.Parsec.Basic", + "root": "lean", + "source_path": "src/lean/Std/Internal/Parsec/Basic.lean", + "source_sha256": "72f8b92d52fd9374b6968776858acee22bde512c8724eab523dc6668ecf87d4b", + "object_path": "lib/lean/Std/Internal/Parsec/Basic.olean", + "object_sha256": "791731d5810b24017a23f0ecd2b11881ab3136974eec4f9ebe7e288733082e2e", + "object_bytes": 354296, + "imports": [ + "Init.NotationExtra", + "Init.Data.ToString.Macro" + ] + }, + { + "module": "Std.Internal.Parsec.String", + "root": "lean", + "source_path": "src/lean/Std/Internal/Parsec/String.lean", + "source_sha256": "38c441b0201c111b2df8e8ad4e29331b157868c9c4548fcbf1f2afa0e782f773", + "object_path": "lib/lean/Std/Internal/Parsec/String.olean", + "object_sha256": "bc5e5a30f81d3d5ec9c47be6bbe9a7ff3481562cc7bbbc729a076b49c23e433b", + "object_bytes": 228072, + "imports": [ + "Std.Internal.Parsec.Basic" + ] + }, + { + "module": "Std.Internal.Parsec.ByteArray", + "root": "lean", + "source_path": "src/lean/Std/Internal/Parsec/ByteArray.lean", + "source_sha256": "82646f5cf6bb1c6e5b2be7b9e9dde4a30d757d06c90f60061290573f576392ab", + "object_path": "lib/lean/Std/Internal/Parsec/ByteArray.olean", + "object_sha256": "fe41aa65200341112bc1495735aff68422f13911aec7c99149405b756511e405", + "object_bytes": 244448, + "imports": [ + "Std.Internal.Parsec.Basic", + "Init.Data.ByteArray.Basic", + "Init.Data.String.Extra" + ] + }, + { + "module": "Std.Internal.Parsec", + "root": "lean", + "source_path": "src/lean/Std/Internal/Parsec.lean", + "source_sha256": "b52960efa41352f7ab12e2f9ea0ef1dbad380e51a2c702b791a9799682dacc34", + "object_path": "lib/lean/Std/Internal/Parsec.olean", + "object_sha256": "d6b09b7fd28a42a79f675b76d430a34b88403a8136cde9fe35100534ba6684fc", + "object_bytes": 18256, + "imports": [ + "Std.Internal.Parsec.Basic", + "Std.Internal.Parsec.String", + "Std.Internal.Parsec.ByteArray" + ] + }, + { + "module": "Lean.Data.Json.Parser", + "root": "lean", + "source_path": "src/lean/Lean/Data/Json/Parser.lean", + "source_sha256": "7afeae9bd7fcd1b8c1f431444bd709803de78be30a6e5cad92a917677ab20c81", + "object_path": "lib/lean/Lean/Data/Json/Parser.olean", + "object_sha256": "1d020424a1f806b55462c6d2f05a3129ceac6f5e4acda9d58478918a5ea8b12d", + "object_bytes": 646704, + "imports": [ + "Lean.Data.Json.Basic", + "Lean.Data.RBMap", + "Std.Internal.Parsec" + ] + }, + { + "module": "Lean.Data.Json.Printer", + "root": "lean", + "source_path": "src/lean/Lean/Data/Json/Printer.lean", + "source_sha256": "c096421b2d89078a3856914242496c7f3f84f3e5c2b87624792ca9b442a24ac8", + "object_path": "lib/lean/Lean/Data/Json/Printer.olean", + "object_sha256": "8f3277d382970f50f4a022b04fa5c5a97f3f7917f5f7beddf38c153457acb241", + "object_bytes": 596688, + "imports": [ + "Lean.Data.Format", + "Lean.Data.Json.Basic", + "Init.Data.List.Impl" + ] + }, + { + "module": "Lean.Data.Json.FromToJson", + "root": "lean", + "source_path": "src/lean/Lean/Data/Json/FromToJson.lean", + "source_sha256": "f4c56c7008a14524f24fdbbcdd7932000a1214b0e03f3751e9564118ed8c1ef3", + "object_path": "lib/lean/Lean/Data/Json/FromToJson.olean", + "object_sha256": "9544b941345a1c0d80bd8d0a0933d783739b5780c785f4ddefe46610bd4b7171", + "object_bytes": 486608, + "imports": [ + "Lean.Data.Json.Basic", + "Lean.Data.Json.Printer" + ] + }, + { + "module": "Lean.Data.Json.Stream", + "root": "lean", + "source_path": "src/lean/Lean/Data/Json/Stream.lean", + "source_sha256": "c1253b8b2aea22008accd5a6ae1254751a15c9c78a08850ca00c5e21655be70a", + "object_path": "lib/lean/Lean/Data/Json/Stream.olean", + "object_sha256": "e35a8f3bcc53ac845bfdf081eaad00a5804d672240d109f893a82b48c4e1c826", + "object_bytes": 50568, + "imports": [ + "Init.System.IO", + "Lean.Data.Json.Parser", + "Lean.Data.Json.Printer", + "Lean.Data.Json.FromToJson" + ] + }, + { + "module": "Lean.Syntax", + "root": "lean", + "source_path": "src/lean/Lean/Syntax.lean", + "source_sha256": "e08f2644d9ea4c38c9c73922e0ce286b4a81732e098bd5c25c3a764e11d563c3", + "object_path": "lib/lean/Lean/Syntax.olean", + "object_sha256": "25a6ec541174ae3514bab8c7cd26f5ffb95ccedd0c3aff2a0eb5a583e8affae7", + "object_bytes": 1296304, + "imports": [ + "Init.Data.Range", + "Init.Data.Hashable", + "Lean.Data.Name", + "Lean.Data.Format", + "Init.Data.Option.Coe" + ] + }, + { + "module": "Lean.Data.Json.Elab", + "root": "lean", + "source_path": "src/lean/Lean/Data/Json/Elab.lean", + "source_sha256": "1c77b9c0d326ccffa35016d417cbd5e7c74db79967b40bc34b6c18415f13048c", + "object_path": "lib/lean/Lean/Data/Json/Elab.olean", + "object_sha256": "e63318264ab31a55c9bf391067447b2b582bda92c6d90ebfdb902eb495a55963", + "object_bytes": 495944, + "imports": [ + "Lean.Data.Json.FromToJson", + "Lean.Syntax" + ] + }, + { + "module": "Lean.Data.Json", + "root": "lean", + "source_path": "src/lean/Lean/Data/Json.lean", + "source_sha256": "9148967fc86a97704b48662830fc4e11d6a602eaacd18cce91ce266a3cb7c130", + "object_path": "lib/lean/Lean/Data/Json.olean", + "object_sha256": "c4b2892dd7693ddcb01adc12f1870b85631538b79fe858590699e524ff9e1e67", + "object_bytes": 18304, + "imports": [ + "Lean.Data.Json.Stream", + "Lean.Data.Json.Printer", + "Lean.Data.Json.Parser", + "Lean.Data.Json.FromToJson", + "Lean.Data.Json.Elab" + ] + }, + { + "module": "Lean.Data.JsonRpc", + "root": "lean", + "source_path": "src/lean/Lean/Data/JsonRpc.lean", + "source_sha256": "64a43b8895ed621fc99ea8ca32335f03c46492184e1d58f56c6facd89affe9c3", + "object_path": "lib/lean/Lean/Data/JsonRpc.olean", + "object_sha256": "3120e816da9e9bb662e592ec09b869cc10ab3fd2652e060ce8cf13001afe7d27", + "object_bytes": 1174072, + "imports": [ + "Init.System.IO", + "Lean.Data.RBTree", + "Lean.Data.Json" + ] + }, + { + "module": "Lean.Data.LBool", + "root": "lean", + "source_path": "src/lean/Lean/Data/LBool.lean", + "source_sha256": "5ec533bf1a249325a25753ac4583f6dd516698aa7df0ef11dd5fd8e39b33daf0", + "object_path": "lib/lean/Lean/Data/LBool.olean", + "object_sha256": "3d188333fe588a9bd17f4b1f5f97c801fd6b18ec22c98fe9d0c142982e7e6698", + "object_bytes": 77624, + "imports": [ + "Init.Data.ToString.Basic" + ] + }, + { + "module": "Lean.Data.LOption", + "root": "lean", + "source_path": "src/lean/Lean/Data/LOption.lean", + "source_sha256": "c19c671bbe8982f48dbc708a483a9c73bcc3c8fb93247bb926daab957592d331", + "object_path": "lib/lean/Lean/Data/LOption.olean", + "object_sha256": "ddc97fd3f851a92f72bd47675c0e48aa8f0e9d22112074725130f958ebe1f98d", + "object_bytes": 103824, + "imports": [ + "Init.Data.ToString.Basic" + ] + }, + { + "module": "Lean.Data.Lsp.Basic", + "root": "lean", + "source_path": "src/lean/Lean/Data/Lsp/Basic.lean", + "source_sha256": "0d70e021abecc898990783cd0d60f002dab60477068cfca341b96c20fbaf26c1", + "object_path": "lib/lean/Lean/Data/Lsp/Basic.olean", + "object_sha256": "2c71d7ebb20c1e38a725f745036dd6f40dd6526dfce275a9b5345b3838547949", + "object_bytes": 2084792, + "imports": [ + "Lean.Data.Json" + ] + }, + { + "module": "Lean.Data.Lsp.CancelParams", + "root": "lean", + "source_path": "src/lean/Lean/Data/Lsp/CancelParams.lean", + "source_sha256": "b7c155e35fc99aa25d7a6329244dd0cb443c98d1d2af403bec6bf7d5d4e9f790", + "object_path": "lib/lean/Lean/Data/Lsp/CancelParams.olean", + "object_sha256": "c15c91f469032f790e526916534a584e69552be179c374b00feb0ec65a0282c9", + "object_bytes": 102960, + "imports": [ + "Lean.Data.JsonRpc" + ] + }, + { + "module": "Lean.Data.Lsp.TextSync", + "root": "lean", + "source_path": "src/lean/Lean/Data/Lsp/TextSync.lean", + "source_sha256": "ed6b11eed1480909e5bdaace230584248035fb763f34ac2b19d80c3984b2f7a9", + "object_path": "lib/lean/Lean/Data/Lsp/TextSync.olean", + "object_sha256": "55452c7745371827407a4ce6b75d9a2df982255d3272fb9a7bc765c1e30223c1", + "object_bytes": 524000, + "imports": [ + "Lean.Data.Json", + "Lean.Data.Lsp.Basic" + ] + }, + { + "module": "Lean.Data.Lsp.LanguageFeatures", + "root": "lean", + "source_path": "src/lean/Lean/Data/Lsp/LanguageFeatures.lean", + "source_sha256": "ac1c16d4645fb6f5e0a1f526d77725af95920fcfa695966dcf290223b151e5b8", + "object_path": "lib/lean/Lean/Data/Lsp/LanguageFeatures.olean", + "object_sha256": "3c71f8fda2afc3b68ab685cf7c8eade2bc28536a624c626701f527d878f754f5", + "object_bytes": 4011584, + "imports": [ + "Lean.Data.Json", + "Lean.Data.Lsp.Basic" + ] + }, + { + "module": "Lean.Data.PersistentHashSet", + "root": "lean", + "source_path": "src/lean/Lean/Data/PersistentHashSet.lean", + "source_sha256": "136f1d2f353ec761c04fb218de006f978b5af33492fd85736a84ef8ede6900cf", + "object_path": "lib/lean/Lean/Data/PersistentHashSet.olean", + "object_sha256": "b788b47a53f587e2330e8427a64734f1a521d0e1a660de5e9e81649858b9f95e", + "object_bytes": 212688, + "imports": [ + "Lean.Data.PersistentHashMap" + ] + }, + { + "module": "Lean.Hygiene", + "root": "lean", + "source_path": "src/lean/Lean/Hygiene.lean", + "source_sha256": "0e3b3a0bb4a76ab0c70b42cd59da12b6f1a911cba68be28be30e35d67b278a5b", + "object_path": "lib/lean/Lean/Hygiene.olean", + "object_sha256": "8ddbd1dd69ed34006c6e4db9d84b3e272f4bb7b0365d712478c56db689b75bdf", + "object_bytes": 236976, + "imports": [ + "Lean.Data.Name", + "Lean.Data.Options", + "Lean.Data.Format" + ] + }, + { + "module": "Lean.Level", + "root": "lean", + "source_path": "src/lean/Lean/Level.lean", + "source_sha256": "4cb369056ec7c01b5468d0f3b2d1951d07a4a543006a6af52d882f568f2470e0", + "object_path": "lib/lean/Lean/Level.olean", + "object_sha256": "048d7c8bf59d90c8585fc003ee77f0a0c4602b1aa04f073db72fdc89a2bd0aae", + "object_bytes": 2254544, + "imports": [ + "Init.Data.Array.QSort", + "Lean.Data.PersistentHashMap", + "Lean.Data.PersistentHashSet", + "Lean.Hygiene", + "Lean.Data.Name", + "Lean.Data.Format", + "Init.Data.Option.Coe" + ] + }, + { + "module": "Lean.Expr", + "root": "lean", + "source_path": "src/lean/Lean/Expr.lean", + "source_sha256": "3e4e57120fcb5755195b080125941f12e8a8433d9a96de6ea6344f97c1715130", + "object_path": "lib/lean/Lean/Expr.olean", + "object_sha256": "abcd6c21273253dfe2e9053a41f92a1d714d878d183b344bfe58593d2caa8acd", + "object_bytes": 3651040, + "imports": [ + "Init.Data.Hashable", + "Init.Data.Int", + "Lean.Data.KVMap", + "Lean.Data.SMap", + "Lean.Level", + "Std.Data.HashSet.Basic" + ] + }, + { + "module": "Lean.ToLevel", + "root": "lean", + "source_path": "src/lean/Lean/ToLevel.lean", + "source_sha256": "e332d5e6598f2eaa5b743863574d4148e3ea732d90f59d240b9804e2e94a112a", + "object_path": "lib/lean/Lean/ToLevel.olean", + "object_sha256": "84060b617bb0edb0460d7b6c246f4d3e7010063113921121bc879883a9eff6c2", + "object_bytes": 45160, + "imports": [ + "Lean.Expr" + ] + }, + { + "module": "Lean.ToExpr", + "root": "lean", + "source_path": "src/lean/Lean/ToExpr.lean", + "source_sha256": "e999a4a1585f6186c5966bad5d92dc55dab85f29dd80b5e9decf2ee5f21284f7", + "object_path": "lib/lean/Lean/ToExpr.olean", + "object_sha256": "baa942f05b658be4668f654c9f62fa99a5df64fc124d83b4688aa3b69b137e5e", + "object_bytes": 460952, + "imports": [ + "Lean.Expr", + "Lean.ToLevel", + "Init.Data.BitVec.Basic", + "Init.Data.SInt.Basic" + ] + }, + { + "module": "Lean.Data.Position", + "root": "lean", + "source_path": "src/lean/Lean/Data/Position.lean", + "source_sha256": "06913ee5b66c89c2e7a689d1fe695dd3d1f441390a3221457ab1f5d78999f84c", + "object_path": "lib/lean/Lean/Data/Position.olean", + "object_sha256": "bf71044f94b5869f11ced0f76f491d27b919467f7ae837e7c8bf8ab3e29655c0", + "object_bytes": 297640, + "imports": [ + "Lean.Data.Format", + "Lean.Data.Json", + "Lean.ToExpr" + ] + }, + { + "module": "Lean.Data.DeclarationRange", + "root": "lean", + "source_path": "src/lean/Lean/Data/DeclarationRange.lean", + "source_sha256": "e8174c325469ccf3e95515cb97d9d8ffc1fcb77a3f3c103c8d67be5ed5415b60", + "object_path": "lib/lean/Lean/Data/DeclarationRange.olean", + "object_sha256": "1c6e9386e37a0dfaeb5454e2727b67aca7fa105d639bb2d5109dfc9475627c81", + "object_bytes": 275216, + "imports": [ + "Lean.Data.Position" + ] + }, + { + "module": "Lean.Data.PrefixTree", + "root": "lean", + "source_path": "src/lean/Lean/Data/PrefixTree.lean", + "source_sha256": "8f94e4eb209e31e98ece3c6c659cb3965333e5d6681e929517081e49ef4aa382", + "object_path": "lib/lean/Lean/Data/PrefixTree.olean", + "object_sha256": "7d7fc70e1d08e9e04d492614497417dd2b332891005dcd83f4021ffc88336cab", + "object_bytes": 307104, + "imports": [ + "Lean.Data.RBMap" + ] + }, + { + "module": "Lean.Data.NameTrie", + "root": "lean", + "source_path": "src/lean/Lean/Data/NameTrie.lean", + "source_sha256": "41b9b43dc2af43c4ff2c85ebe8cd5176cdf31cb40c6478615efbbf5ec64a77d4", + "object_path": "lib/lean/Lean/Data/NameTrie.olean", + "object_sha256": "3e9757a0f616711d0e395139ad0334b2a1273a0c20b96bb7251edbb81cf33a0f", + "object_bytes": 192744, + "imports": [ + "Lean.Data.PrefixTree" + ] + }, + { + "module": "Lean.Util.Path", + "root": "lean", + "source_path": "src/lean/Lean/Util/Path.lean", + "source_sha256": "c3b5b1dd68b2a20051e85aecfa39ddf39ff2933f0c89cb5fc76f966925f21f65", + "object_path": "lib/lean/Lean/Util/Path.olean", + "object_sha256": "e75a7afd06fd53219ce618d12cb4514beb376dab9da373021fb8e78fc70b6a00", + "object_bytes": 397432, + "imports": [ + "Init.System.IO" + ] + }, + { + "module": "Lean.Util.Paths", + "root": "lean", + "source_path": "src/lean/Lean/Util/Paths.lean", + "source_sha256": "a1db3b5f9055009c9057495e0bd3bf73b8ea43689daafc147a5c8441c32d5fb4", + "object_path": "lib/lean/Lean/Util/Paths.olean", + "object_sha256": "2f066f713e67f3039c2985ded2d4521e8e88d6d7ab7a43eb0aaad0ebfb1c590f", + "object_bytes": 163056, + "imports": [ + "Lean.Data.Json", + "Lean.Util.Path" + ] + }, + { + "module": "Lean.Util.LeanOptions", + "root": "lean", + "source_path": "src/lean/Lean/Util/LeanOptions.lean", + "source_sha256": "1cd22b7e4c2bda4db2a8c2db546e91b56b3c57249978f503562079079ec21bd8", + "object_path": "lib/lean/Lean/Util/LeanOptions.olean", + "object_sha256": "126f942f6b4e3ba3b5f9456e5b31d288d8e754ffcb90f8e06d24f9a6bebc4982", + "object_bytes": 413184, + "imports": [ + "Lean.Util.Paths" + ] + }, + { + "module": "Lean.Setup", + "root": "lean", + "source_path": "src/lean/Lean/Setup.lean", + "source_sha256": "b97be12e3ffef4316d0b185c2bed5e9dea077189ad0b203fe2b4394d340eca31", + "object_path": "lib/lean/Lean/Setup.olean", + "object_sha256": "3b7cc24d6ac67f40d5dd0d34f48ee4c24bf1988dd4fcc5c6e27c9580da366af8", + "object_bytes": 597592, + "imports": [ + "Lean.Data.Json", + "Lean.Util.LeanOptions" + ] + }, + { + "module": "Lean.Declaration", + "root": "lean", + "source_path": "src/lean/Lean/Declaration.lean", + "source_sha256": "9cafb01f06616f04971906858b7cacbaf63c43fa1c13d29af7c64b6c840e9d8e", + "object_path": "lib/lean/Lean/Declaration.olean", + "object_sha256": "1f2306b92dc7aac7907061a6799e1e3ced230ec7bb058d5b8485c2add598afd8", + "object_bytes": 1313952, + "imports": [ + "Lean.Expr" + ] + }, + { + "module": "Lean.Data.PersistentArray", + "root": "lean", + "source_path": "src/lean/Lean/Data/PersistentArray.lean", + "source_sha256": "77794d6053522d8a03437c6a1403ac45cca04200f1e25267616216d8bb3cb2e6", + "object_path": "lib/lean/Lean/Data/PersistentArray.olean", + "object_sha256": "81c6aa8866dd77bf05e2a3eaf7a939e1e5521fffadb594f4ad228541efa33847", + "object_bytes": 1391424, + "imports": [ + "Init.Data.Nat.Fold", + "Init.Data.Array.Basic", + "Init.NotationExtra", + "Init.Data.ToString.Macro", + "Init.Data.UInt.Basic" + ] + }, + { + "module": "Lean.LocalContext", + "root": "lean", + "source_path": "src/lean/Lean/LocalContext.lean", + "source_sha256": "7b56f0080f81249305331a80da8dd40a32202a1b722373ad419f4071cceb31e8", + "object_path": "lib/lean/Lean/LocalContext.olean", + "object_sha256": "3e95c16073da535a34ca39c379b301b8e5bfec482d23c54a6aa538a404e2293a", + "object_bytes": 1439920, + "imports": [ + "Init.Data.Nat.Control", + "Lean.Data.PersistentArray", + "Lean.Expr", + "Lean.Hygiene" + ] + }, + { + "module": "Lean.Util.FindExpr", + "root": "lean", + "source_path": "src/lean/Lean/Util/FindExpr.lean", + "source_sha256": "15d12df3da7fca5d4ac9c925850d04bacab3d5093bbaf150c9f48c9e19a40a19", + "object_path": "lib/lean/Lean/Util/FindExpr.olean", + "object_sha256": "4032897646d62696353c7744aa28bf5fcca45d64d7541c0471dde2147c1fd345", + "object_bytes": 55672, + "imports": [ + "Lean.Expr" + ] + }, + { + "module": "Lean.Util.Profile", + "root": "lean", + "source_path": "src/lean/Lean/Util/Profile.lean", + "source_sha256": "e49b40c437dbae29d004fbbf2256dc3e982c4503db2d30c59f8cdfd80aa2c6a6", + "object_path": "lib/lean/Lean/Util/Profile.olean", + "object_sha256": "981b88aa9d5485f745f30b1761ddfc706116492d6b7c954c2bd472787d5cb882", + "object_bytes": 95864, + "imports": [ + "Init.Data.OfScientific", + "Lean.Data.Options" + ] + }, + { + "module": "Lean.Util.PtrSet", + "root": "lean", + "source_path": "src/lean/Lean/Util/PtrSet.lean", + "source_sha256": "69b1c29b8ba5137053d30eddebd44bc62d803c2f6b1710420e40644768dae598", + "object_path": "lib/lean/Lean/Util/PtrSet.olean", + "object_sha256": "8638f98f380c09bfba7d253a986a26fd267b8a852f8e3461caf682533159ad31", + "object_bytes": 218560, + "imports": [ + "Init.Data.Hashable", + "Std.Data.HashSet.Basic", + "Std.Data.HashMap.Basic" + ] + }, + { + "module": "Lean.Util.ReplaceExpr", + "root": "lean", + "source_path": "src/lean/Lean/Util/ReplaceExpr.lean", + "source_sha256": "080a74a8fbb6e4813bb38673f78c1ab0ff677942c8343ebcdbd1f37b98397022", + "object_path": "lib/lean/Lean/Util/ReplaceExpr.olean", + "object_sha256": "de54988f9b6700013ee441ed3b0053c102392ae1e16d1c31a7e9d93c9bd57904", + "object_bytes": 98632, + "imports": [ + "Lean.Expr", + "Lean.Util.PtrSet" + ] + }, + { + "module": "Lean.Util.InstantiateLevelParams", + "root": "lean", + "source_path": "src/lean/Lean/Util/InstantiateLevelParams.lean", + "source_sha256": "9bf07e176c46d5a1b26096062964016fa7e334bc5ec974272fefc870e64a8278", + "object_path": "lib/lean/Lean/Util/InstantiateLevelParams.olean", + "object_sha256": "8e09d27397b9b0529427376deae300fc50589c4b3a0dcee70c85543014f8f3a3", + "object_bytes": 158544, + "imports": [ + "Lean.Util.ReplaceExpr" + ] + }, + { + "module": "Lean.Util.FoldConsts", + "root": "lean", + "source_path": "src/lean/Lean/Util/FoldConsts.lean", + "source_sha256": "81731982284c3700fe3acfe2ceb16218ea49a563ee5ef1d3b272e8b6d924eae1", + "object_path": "lib/lean/Lean/Util/FoldConsts.olean", + "object_sha256": "058467e9f0b6831fb284a4c8eb2b2f0a3e840e8830b10db321e196cef66942e3", + "object_bytes": 222760, + "imports": [ + "Lean.Expr", + "Lean.Util.PtrSet", + "Lean.Declaration" + ] + }, + { + "module": "Lean.PrivateName", + "root": "lean", + "source_path": "src/lean/Lean/PrivateName.lean", + "source_sha256": "5e611cea30efd0c260188e24243ba6db635c307c2543a4862cc3de305e94898f", + "object_path": "lib/lean/Lean/PrivateName.olean", + "object_sha256": "1edce4942e767cefd8462cb297632f175f3b0ba4ed82607b883b75a1b4849b7b", + "object_bytes": 85168, + "imports": [ + "Init.Notation", + "Init.Data.Option.Coe" + ] + }, + { + "module": "Lean.LoadDynlib", + "root": "lean", + "source_path": "src/lean/Lean/LoadDynlib.lean", + "source_sha256": "9790b40c3aa34e1963cb77903e0e2960caf3f5f4f4ee48ae4d86ecbb63cf404f", + "object_path": "lib/lean/Lean/LoadDynlib.olean", + "object_sha256": "e83d2286fa0ba67fa0d4cdd5aa7b31cbd571877e6ca19aaefd3fb8ba10bb43f3", + "object_bytes": 94304, + "imports": [ + "Init.System.IO" + ] + }, + { + "module": "Lean.Environment", + "root": "lean", + "source_path": "src/lean/Lean/Environment.lean", + "source_sha256": "a67b5bf3d2aeeccaf2c88752a605d44448d4b1dabc7058c5c2c8fada0edf1468", + "object_path": "lib/lean/Lean/Environment.olean", + "object_sha256": "dc88da8a76b3c144e0a03b66fb8e8f48217c83bc3da52018e47864b135afb092", + "object_bytes": 4781760, + "imports": [ + "Init.Control.StateRef", + "Init.Data.Array.BinSearch", + "Init.Data.Stream", + "Init.System.Promise", + "Lean.ImportingFlag", + "Lean.Data.NameTrie", + "Lean.Data.SMap", + "Lean.Setup", + "Lean.Declaration", + "Lean.LocalContext", + "Lean.Util.Path", + "Lean.Util.FindExpr", + "Lean.Util.Profile", + "Lean.Util.InstantiateLevelParams", + "Lean.Util.FoldConsts", + "Lean.PrivateName", + "Lean.LoadDynlib", + "Init.Dynamic" + ] + }, + { + "module": "Lean.Data.OpenDecl", + "root": "lean", + "source_path": "src/lean/Lean/Data/OpenDecl.lean", + "source_sha256": "3aa34565e9ac51c852c1b906f07b11e8ad7e0e56adc44c547f23a3d4c5f37075", + "object_path": "lib/lean/Lean/Data/OpenDecl.olean", + "object_sha256": "42a62c09ddb50cd723e5a7414f8e432771bc6d0ba16559cf93131c67011d683f", + "object_bytes": 115280, + "imports": [ + "Init.Meta" + ] + }, + { + "module": "Lean.Util.MonadCache", + "root": "lean", + "source_path": "src/lean/Lean/Util/MonadCache.lean", + "source_sha256": "faeb9b23d17c384abc5ddfdb11794036e7c75b5e183099cb406eeb6bd1be81bb", + "object_path": "lib/lean/Lean/Util/MonadCache.olean", + "object_sha256": "6a8b59ba7b1f0eabc3986b91982cf5ea681fb37d752ad1c97472f9cca8249323", + "object_bytes": 305440, + "imports": [ + "Init.Control.StateRef", + "Std.Data.HashMap.Basic" + ] + }, + { + "module": "Lean.MetavarContext", + "root": "lean", + "source_path": "src/lean/Lean/MetavarContext.lean", + "source_sha256": "19f1d61557060f04e88bbab1a0af6e1cbceb63a0367d52f885b4d5cd258d72f1", + "object_path": "lib/lean/Lean/MetavarContext.olean", + "object_sha256": "5e5fa858f161573a33d40008a75306d68eac68c5cf8e479e0f5be308f17d9dc2", + "object_bytes": 4409152, + "imports": [ + "Init.ShareCommon", + "Lean.Util.MonadCache", + "Lean.LocalContext" + ] + }, + { + "module": "Lean.Server.Rpc.Basic", + "root": "lean", + "source_path": "src/lean/Lean/Server/Rpc/Basic.lean", + "source_sha256": "e82ca26e1fc921d5044b1330be386acca1c05a13f3a08e570ec9807c782d23e3", + "object_path": "lib/lean/Lean/Server/Rpc/Basic.olean", + "object_sha256": "c67f0442919bb18fd5569c94f61442fa175d2544e7261e0d6394208caa192193", + "object_bytes": 446544, + "imports": [ + "Init.Dynamic", + "Lean.Data.Json" + ] + }, + { + "module": "Lean.Widget.Types", + "root": "lean", + "source_path": "src/lean/Lean/Widget/Types.lean", + "source_sha256": "0ff93e3ff3d1f8064c56b1f972ea05258ed9a66a4ee985e40d190d95b46f5027", + "object_path": "lib/lean/Lean/Widget/Types.olean", + "object_sha256": "504e18043ec3b9bf25ef4e2c62188cf90e6e120ffe8115785934df6ff5e0ec09", + "object_bytes": 218432, + "imports": [ + "Lean.Server.Rpc.Basic" + ] + }, + { + "module": "Lean.Elab.InfoTree.Types", + "root": "lean", + "source_path": "src/lean/Lean/Elab/InfoTree/Types.lean", + "source_sha256": "aaced7b0de74ffb3b6c8a0304aa33ef72f2301cc1d449e71d39c538d78383b8a", + "object_path": "lib/lean/Lean/Elab/InfoTree/Types.olean", + "object_sha256": "18856bac43bd1bf4492ee50eb350ac472fffc1b1199bb51e79d4b5e08516eea1", + "object_bytes": 1089280, + "imports": [ + "Lean.Data.DeclarationRange", + "Lean.Data.OpenDecl", + "Lean.MetavarContext", + "Lean.Environment", + "Lean.Data.Json", + "Lean.Server.Rpc.Basic", + "Lean.Widget.Types" + ] + }, + { + "module": "Lean.Util.PPExt", + "root": "lean", + "source_path": "src/lean/Lean/Util/PPExt.lean", + "source_sha256": "0038635558f902af2fc6b894a342264a2b4dcf258c1ecb296997a498f8216666", + "object_path": "lib/lean/Lean/Util/PPExt.olean", + "object_sha256": "8f957741c815e61a222511b7fd8417d23737b5be4149179f88f4ba87ac5b05ee", + "object_bytes": 342808, + "imports": [ + "Lean.Environment", + "Lean.MetavarContext", + "Lean.Data.OpenDecl", + "Lean.Elab.InfoTree.Types" + ] + }, + { + "module": "Lean.Util.Sorry", + "root": "lean", + "source_path": "src/lean/Lean/Util/Sorry.lean", + "source_sha256": "74ff9f8a7d4961b181771d3721f4df1533d78ac39990b270f1ad401b59355fe1", + "object_path": "lib/lean/Lean/Util/Sorry.olean", + "object_sha256": "463cdd4d5cf4195075cf49e2dfc4b3560734e10947c642748008547da7726e3e", + "object_bytes": 95920, + "imports": [ + "Lean.Util.FindExpr", + "Lean.Declaration" + ] + }, + { + "module": "Lean.Message", + "root": "lean", + "source_path": "src/lean/Lean/Message.lean", + "source_sha256": "7df83c3ee73180116b744eba1d88ef36c5c09f6d335a9735fbc1192a88e9f011", + "object_path": "lib/lean/Lean/Message.olean", + "object_sha256": "ebbf46dea574db23f2c022eb4861977932018282c8e7ba536a0ecd5f6e57c7de", + "object_bytes": 1812464, + "imports": [ + "Lean.Data.Position", + "Lean.Data.OpenDecl", + "Lean.MetavarContext", + "Lean.Environment", + "Lean.Util.PPExt", + "Lean.Util.Sorry" + ] + }, + { + "module": "Lean.InternalExceptionId", + "root": "lean", + "source_path": "src/lean/Lean/InternalExceptionId.lean", + "source_sha256": "0572153b73f57742b1332f81ab6d1a66001b45f8576e45ee16b44307c898b737", + "object_path": "lib/lean/Lean/InternalExceptionId.olean", + "object_sha256": "065adda38e5d80c7c2591af00756e2c4eac6327331b12e78e960eb0754e6ed53", + "object_bytes": 114128, + "imports": [ + "Init.System.IO" + ] + }, + { + "module": "Lean.Exception", + "root": "lean", + "source_path": "src/lean/Lean/Exception.lean", + "source_sha256": "a35bdb0e96f2f17111beaabb67d40117a08aa21a37b225b17d0d5a88728ff226", + "object_path": "lib/lean/Lean/Exception.olean", + "object_sha256": "7929a04e961317b11f28707b348c61524fb09e504acc8dbe0b9da1642547ee87", + "object_bytes": 425816, + "imports": [ + "Lean.Message", + "Lean.InternalExceptionId", + "Lean.Data.Options", + "Lean.Util.MonadCache" + ] + }, + { + "module": "Lean.Log", + "root": "lean", + "source_path": "src/lean/Lean/Log.lean", + "source_sha256": "59885d6968248460743d2a9246cf48ef74cf7a982d7fbc937aa3ba7a9ef0915c", + "object_path": "lib/lean/Lean/Log.olean", + "object_sha256": "f3effdfb548f30e19c8d6537f03ef88c034468c83bd1cba08fb8cddceee14ac3", + "object_bytes": 202224, + "imports": [ + "Lean.Util.Sorry", + "Lean.Message" + ] + }, + { + "module": "Lean.EnvExtension", + "root": "lean", + "source_path": "src/lean/Lean/EnvExtension.lean", + "source_sha256": "ddab0b7201438a5a29a92a8faf295c9f816a1aa2cc0ef5d71a536a26fc522102", + "object_path": "lib/lean/Lean/EnvExtension.olean", + "object_sha256": "b709cdd48833532ee9405dae8fa2fd45f5d5d5c28973a677b99a593bb0d73cda", + "object_bytes": 470672, + "imports": [ + "Lean.Environment" + ] + }, + { + "module": "Lean.AuxRecursor", + "root": "lean", + "source_path": "src/lean/Lean/AuxRecursor.lean", + "source_sha256": "a45d121dd32d06bafc94c39a1e6f461ff62ddca29bd7af4b9e1ceff96750343b", + "object_path": "lib/lean/Lean/AuxRecursor.olean", + "object_sha256": "6253646bb112459ca1172db79d82432cc6de93ab32b868d22122d824d819a5d4", + "object_bytes": 85240, + "imports": [ + "Lean.EnvExtension" + ] + }, + { + "module": "Lean.Compiler.Old", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/Old.lean", + "source_sha256": "0b7276130d54a18ad471bd96c97928ee721f00beba380f5c27d1ce04d4e54094", + "object_path": "lib/lean/Lean/Compiler/Old.olean", + "object_sha256": "51dc4359fe28ed5e192ed60045409ca6727011784fd88b82c534a3d67b1ed763", + "object_bytes": 104504, + "imports": [ + "Lean.Environment" + ] + }, + { + "module": "Lean.MonadEnv", + "root": "lean", + "source_path": "src/lean/Lean/MonadEnv.lean", + "source_sha256": "6765bb9d0181f9333cd4056a7ee133c390a53c6d7f205a7e8732a833c071869c", + "object_path": "lib/lean/Lean/MonadEnv.olean", + "object_sha256": "d4bc4153b51123c9d88cc5ac68d29065f8656393f2bf460e68f19d43b83000ff", + "object_bytes": 431736, + "imports": [ + "Lean.Environment", + "Lean.Exception", + "Lean.Declaration", + "Lean.Log", + "Lean.AuxRecursor", + "Lean.Compiler.Old" + ] + }, + { + "module": "Lean.DeclarationRange", + "root": "lean", + "source_path": "src/lean/Lean/DeclarationRange.lean", + "source_sha256": "aafc6cf2746ce0b0b2897082182f04ec2cbfa4dd479099893c0b0e75b800827a", + "object_path": "lib/lean/Lean/DeclarationRange.olean", + "object_sha256": "ca20f357ed19f075fcfbcaa2f6c829285b409065e973bf71acc9548a37713e68", + "object_bytes": 101552, + "imports": [ + "Lean.Data.DeclarationRange", + "Lean.MonadEnv" + ] + }, + { + "module": "Lean.Data.Lsp.Utf16", + "root": "lean", + "source_path": "src/lean/Lean/Data/Lsp/Utf16.lean", + "source_sha256": "03834c2fd0220f3c82972c178e69c0d75512e2b580ee8d5648a50f6f1c6fbaec", + "object_path": "lib/lean/Lean/Data/Lsp/Utf16.olean", + "object_sha256": "ef44dd13ec04f7c3b41848ab511c4deba8b039b15cce11ca86d35dd9deaa0822", + "object_bytes": 125976, + "imports": [ + "Init.Data.String", + "Lean.Data.Lsp.Basic", + "Lean.Data.Position", + "Lean.DeclarationRange" + ] + }, + { + "module": "Lean.Data.Lsp.Diagnostics", + "root": "lean", + "source_path": "src/lean/Lean/Data/Lsp/Diagnostics.lean", + "source_sha256": "06c15bc9801c02b6c590936698e3bac483041f1ef16423a68b8ac0db0e836aad", + "object_path": "lib/lean/Lean/Data/Lsp/Diagnostics.olean", + "object_sha256": "d6809304c1cf4f178cc4f4df4caa536e9de6e8f1d2bd862e706561632cc3da5f", + "object_bytes": 936824, + "imports": [ + "Lean.Data.Json", + "Lean.Data.Lsp.Basic", + "Lean.Data.Lsp.Utf16", + "Lean.Message" + ] + }, + { + "module": "Lean.Data.Lsp.CodeActions", + "root": "lean", + "source_path": "src/lean/Lean/Data/Lsp/CodeActions.lean", + "source_sha256": "fe7b20918a4e523cfc5b76d301decb499e93cc74ee5c9c2fc2a7bf9b0b25273d", + "object_path": "lib/lean/Lean/Data/Lsp/CodeActions.olean", + "object_sha256": "370cacbb1e4defc44116e59c7db7e7d74fb576bb9c164c497757e0f08ef29c0d", + "object_bytes": 814120, + "imports": [ + "Lean.Data.Json", + "Lean.Data.Lsp.Basic", + "Lean.Data.Lsp.Diagnostics" + ] + }, + { + "module": "Lean.Data.Lsp.Capabilities", + "root": "lean", + "source_path": "src/lean/Lean/Data/Lsp/Capabilities.lean", + "source_sha256": "dee2cec07d686c6cc12e228d72c25856d4f56836168800cd56d56f2f07bf2091", + "object_path": "lib/lean/Lean/Data/Lsp/Capabilities.olean", + "object_sha256": "f49620da72f62ec211899f5f0404f71f21b1fce3c1605a777019839e4d713c64", + "object_bytes": 893544, + "imports": [ + "Lean.Data.JsonRpc", + "Lean.Data.Lsp.TextSync", + "Lean.Data.Lsp.LanguageFeatures", + "Lean.Data.Lsp.CodeActions" + ] + }, + { + "module": "Lean.Data.Lsp.Client", + "root": "lean", + "source_path": "src/lean/Lean/Data/Lsp/Client.lean", + "source_sha256": "12b53e4748926fc0e79db49e8dc580d23e291508c73d8fc51be145e701109b52", + "object_path": "lib/lean/Lean/Data/Lsp/Client.olean", + "object_sha256": "d49407ae3402b9c5adea67f8e408a8a277c4c8be5275194f513a6bf245b08361", + "object_bytes": 176520, + "imports": [ + "Lean.Data.Lsp.Basic", + "Lean.Data.Json" + ] + }, + { + "module": "Lean.Data.Lsp.Communication", + "root": "lean", + "source_path": "src/lean/Lean/Data/Lsp/Communication.lean", + "source_sha256": "142d07a483486e7aa5d5cfc705208fed922fd1515a0984fc55004f03b588206c", + "object_path": "lib/lean/Lean/Data/Lsp/Communication.olean", + "object_sha256": "1aa5b9ed11d27d4c928b70ac3593ee2fcacaece775d236b2472ada79840a5fce", + "object_bytes": 315512, + "imports": [ + "Init.System.IO", + "Lean.Data.JsonRpc" + ] + }, + { + "module": "Lean.Data.Lsp.Extra", + "root": "lean", + "source_path": "src/lean/Lean/Data/Lsp/Extra.lean", + "source_sha256": "cc26b0ed0ca9e895a90c16d13ba7e61baf20741b920c67d6b2b81ac859ea53a6", + "object_path": "lib/lean/Lean/Data/Lsp/Extra.olean", + "object_sha256": "4e48da6e7db266c7fa30338269a57f84010aa9804a0d8a15c655546aa43f476c", + "object_bytes": 917952, + "imports": [ + "Lean.Data.Lsp.Basic", + "Lean.Data.Lsp.TextSync", + "Lean.Server.Rpc.Basic" + ] + }, + { + "module": "Lean.Data.Lsp.Workspace", + "root": "lean", + "source_path": "src/lean/Lean/Data/Lsp/Workspace.lean", + "source_sha256": "33fae574ee396b6abffec36611d5a6ae3b27a9a6b6ec400156739c9eba899cae", + "object_path": "lib/lean/Lean/Data/Lsp/Workspace.olean", + "object_sha256": "16f677e2233744861ced70b6efb541bac154d2c6789eb1842b946462df227931", + "object_bytes": 354456, + "imports": [ + "Lean.Data.Lsp.Basic", + "Lean.Data.Json" + ] + }, + { + "module": "Lean.Data.Lsp.InitShutdown", + "root": "lean", + "source_path": "src/lean/Lean/Data/Lsp/InitShutdown.lean", + "source_sha256": "c24b03c646ff43c39bf9376019669c87a97f1c83ec95d0b60ae09689b655bb11", + "object_path": "lib/lean/Lean/Data/Lsp/InitShutdown.olean", + "object_sha256": "0c6795631fd326fed51d5465466c70b6fd2f47fa43a0bfea092a270f641bb6a6", + "object_bytes": 504632, + "imports": [ + "Lean.Data.Lsp.Capabilities", + "Lean.Data.Lsp.Workspace", + "Lean.Data.Json" + ] + }, + { + "module": "Std.Classes.Ord.Basic", + "root": "lean", + "source_path": "src/lean/Std/Classes/Ord/Basic.lean", + "source_sha256": "efb068a9db006e6a4747f8232de7be87b40cdf396ec8a72e25ace38ad50cc5ff", + "object_path": "lib/lean/Std/Classes/Ord/Basic.olean", + "object_sha256": "55a1aa749ffff07a3fe2c1409bc80f7051821ee6bad5e9a4ea55c4c92fe5a6c5", + "object_bytes": 633016, + "imports": [ + "Init.Data.Ord" + ] + }, + { + "module": "Std.Data.DTreeMap.Internal.Def", + "root": "lean", + "source_path": "src/lean/Std/Data/DTreeMap/Internal/Def.lean", + "source_sha256": "2eb9d3993d2b3f6bfa63cdd5f9455af8a52c197547973b160d06011a8acb454a", + "object_path": "lib/lean/Std/Data/DTreeMap/Internal/Def.olean", + "object_sha256": "75100453be292170dd8d543d89c3eaec25b585827cd7b03f9ddf051a2d9b572c", + "object_bytes": 144464, + "imports": [ + "Std.Classes.Ord.Basic" + ] + }, + { + "module": "Std.Data.DTreeMap.Internal.Balanced", + "root": "lean", + "source_path": "src/lean/Std/Data/DTreeMap/Internal/Balanced.lean", + "source_sha256": "b9ced8e7290e1b08af2a62c32c9660af97fd443b99b146c8201eb5cc8af88d66", + "object_path": "lib/lean/Std/Data/DTreeMap/Internal/Balanced.olean", + "object_sha256": "9fd0d507ec82c969da74b59d6b5d7fc878b0c7854384cefbddb0adcbedf33efe", + "object_bytes": 257104, + "imports": [ + "Init.Data.AC", + "Std.Data.DTreeMap.Internal.Def" + ] + }, + { + "module": "Std.Data.DTreeMap.Internal.Balancing", + "root": "lean", + "source_path": "src/lean/Std/Data/DTreeMap/Internal/Balancing.lean", + "source_sha256": "4e88136c97efff8ed349740e85402cb0fc782e8ed869575891b7bc0b41a67f9d", + "object_path": "lib/lean/Std/Data/DTreeMap/Internal/Balancing.olean", + "object_sha256": "9277f1b0127d74c0ca88711b0a7d3731e288066d48e98984a56e5f5d27ae4774", + "object_bytes": 8775016, + "imports": [ + "Init.Data.AC", + "Std.Data.DTreeMap.Internal.Balanced" + ] + }, + { + "module": "Std.Data.Internal.Cut", + "root": "lean", + "source_path": "src/lean/Std/Data/Internal/Cut.lean", + "source_sha256": "8ad1f6ee5480429501505d862dd69912e8942957c0ed1259eccf482bf0ea3bf7", + "object_path": "lib/lean/Std/Data/Internal/Cut.olean", + "object_sha256": "b4c9989c247a76a65e71a52718e678e33e8b6a18db827e0009dec7de7171a6df", + "object_bytes": 77528, + "imports": [ + "Init.Data.Ord" + ] + }, + { + "module": "Std.Data.DTreeMap.Internal.Ordered", + "root": "lean", + "source_path": "src/lean/Std/Data/DTreeMap/Internal/Ordered.lean", + "source_sha256": "95da61c14ce584cd49e3ef194813efe0e0837b0a29b66563f9e7a50122fdcb6f", + "object_path": "lib/lean/Std/Data/DTreeMap/Internal/Ordered.olean", + "object_sha256": "45af23491087c8741b1375eea11dad9a822af442aa01d70e446ee7f4f9626e9a", + "object_bytes": 58008, + "imports": [ + "Std.Classes.Ord.Basic", + "Std.Data.DTreeMap.Internal.Def", + "Std.Data.Internal.Cut" + ] + }, + { + "module": "Std.Data.DTreeMap.Internal.Queries", + "root": "lean", + "source_path": "src/lean/Std/Data/DTreeMap/Internal/Queries.lean", + "source_sha256": "1fe091ffc0ce4e5abf2fccc17451d100b4f2d6ec944ad284736f8ad2d5281189", + "object_path": "lib/lean/Std/Data/DTreeMap/Internal/Queries.olean", + "object_sha256": "40adc37e64c4ccda7f4c6efda858031efe8299fd64ea65a78e26e089e5c89055", + "object_bytes": 3739744, + "imports": [ + "Init.Data.Nat.Compare", + "Std.Data.DTreeMap.Internal.Def", + "Std.Data.DTreeMap.Internal.Balanced", + "Std.Data.DTreeMap.Internal.Ordered", + "Std.Classes.Ord.Basic" + ] + }, + { + "module": "Std.Data.DTreeMap.Internal.Operations", + "root": "lean", + "source_path": "src/lean/Std/Data/DTreeMap/Internal/Operations.lean", + "source_sha256": "185a0cd2ac2e8fc407cbb7a5f001d2fc58f07e9b73d97fd1f847a82f038ee1c0", + "object_path": "lib/lean/Std/Data/DTreeMap/Internal/Operations.olean", + "object_sha256": "fbf54bcb6ca161d57e27d5eed82cf2841659b72c6dde2cc10cd8b4be518c4a05", + "object_bytes": 10702208, + "imports": [ + "Init.Data.Nat.Compare", + "Std.Data.DTreeMap.Internal.Balancing", + "Std.Data.DTreeMap.Internal.Queries", + "Std.Classes.Ord.Basic" + ] + }, + { + "module": "Std.Data.DTreeMap.Internal.WF.Defs", + "root": "lean", + "source_path": "src/lean/Std/Data/DTreeMap/Internal/WF/Defs.lean", + "source_sha256": "cfb13df0fc28e1d20cdde69a3e9538b71a95c4e42f066ca5e014ed3e636899ac", + "object_path": "lib/lean/Std/Data/DTreeMap/Internal/WF/Defs.olean", + "object_sha256": "60815fe4907c3530970bd8674e191d2f0ae3c26ad170825fd3ff6fb3e6c06361", + "object_bytes": 363608, + "imports": [ + "Std.Data.DTreeMap.Internal.Operations" + ] + }, + { + "module": "Std.Data.DTreeMap.Basic", + "root": "lean", + "source_path": "src/lean/Std/Data/DTreeMap/Basic.lean", + "source_sha256": "aafee7c4937170d20dc9c4d68b5dbc4f4bc1d4f6ee406deb8c58121ff3ac5594", + "object_path": "lib/lean/Std/Data/DTreeMap/Basic.olean", + "object_sha256": "7c3856d3868b4eff40b26deb42d258fac22fab00ce7a4c363d108f1a509dbff2", + "object_bytes": 2430104, + "imports": [ + "Std.Data.DTreeMap.Internal.WF.Defs" + ] + }, + { + "module": "Std.Data.TreeMap.Basic", + "root": "lean", + "source_path": "src/lean/Std/Data/TreeMap/Basic.lean", + "source_sha256": "41889e4c816e81e38b806ba77d9afbc9ba54657cb3752f85afadede9f6093cdb", + "object_path": "lib/lean/Std/Data/TreeMap/Basic.olean", + "object_sha256": "2d35e430ed7f8d424a716ff0cb43d6087845171127f01cdd8ed3700b23b49556", + "object_bytes": 1762592, + "imports": [ + "Std.Data.DTreeMap.Basic" + ] + }, + { + "module": "Std.Data.DTreeMap.Raw.Basic", + "root": "lean", + "source_path": "src/lean/Std/Data/DTreeMap/Raw/Basic.lean", + "source_sha256": "a674c5dc3c25bd632a8b33c55ba85c11b33a55723c7ba7b56cb1565197478470", + "object_path": "lib/lean/Std/Data/DTreeMap/Raw/Basic.olean", + "object_sha256": "f50478d54afb7117d39ced2cc1a45dcf83e07cc6dbbc3526d542f466f4b20a4c", + "object_bytes": 2688272, + "imports": [ + "Std.Data.DTreeMap.Internal.WF.Defs", + "Std.Data.DTreeMap.Basic" + ] + }, + { + "module": "Std.Data.TreeMap.Raw.Basic", + "root": "lean", + "source_path": "src/lean/Std/Data/TreeMap/Raw/Basic.lean", + "source_sha256": "5bd76102ba678dc9fa87910af388813bde8b08e1af554d19716e8ee34e94150e", + "object_path": "lib/lean/Std/Data/TreeMap/Raw/Basic.olean", + "object_sha256": "325ab6acf248498f72ec6278591fd9deb763d8866667c6732dda79367320c0d8", + "object_bytes": 2076536, + "imports": [ + "Std.Data.DTreeMap.Raw.Basic" + ] + }, + { + "module": "Std.Data.Internal.List.Associative", + "root": "lean", + "source_path": "src/lean/Std/Data/Internal/List/Associative.lean", + "source_sha256": "35515e0f422dc1d1d9e419a065a7d399079497cc0b5028dd7cebafa4467fa95c", + "object_path": "lib/lean/Std/Data/Internal/List/Associative.olean", + "object_sha256": "89b153dcf0414d344cf17d281693c28cfa308d122b18460696740d628c165c62", + "object_bytes": 7534272, + "imports": [ + "Init.Data.BEq", + "Init.Data.Nat.Simproc", + "Init.Data.Option.Attach", + "Init.Data.List.Perm", + "Init.Data.List.Find", + "Init.Data.List.MinMax", + "Init.Data.List.Monadic", + "Std.Data.Internal.List.Defs", + "Std.Classes.Ord.Basic" + ] + }, + { + "module": "Std.Data.DTreeMap.Internal.Cell", + "root": "lean", + "source_path": "src/lean/Std/Data/DTreeMap/Internal/Cell.lean", + "source_sha256": "6a7bf07daa60490c3f043708d313952ba8920bb26836a3e9830bad0ca2de25ad", + "object_path": "lib/lean/Std/Data/DTreeMap/Internal/Cell.olean", + "object_sha256": "15b028b270db68be9f7cfea01c4698db168221f330faffb719b797e96c5fb616", + "object_bytes": 231280, + "imports": [ + "Std.Classes.Ord.Basic", + "Std.Data.Internal.List.Associative" + ] + }, + { + "module": "Std.Data.DTreeMap.Internal.Model", + "root": "lean", + "source_path": "src/lean/Std/Data/DTreeMap/Internal/Model.lean", + "source_sha256": "3cf07ee0cf1c4e3028430ed30ef0fc16a16ac79e52de744ead259b794ae6ca8f", + "object_path": "lib/lean/Std/Data/DTreeMap/Internal/Model.olean", + "object_sha256": "e3a9e09d09b1a4a0230062f1847a244f65a914fc2be3b20e69239e47dfe03eed", + "object_bytes": 4402064, + "imports": [ + "Std.Data.DTreeMap.Internal.WF.Defs", + "Std.Data.DTreeMap.Internal.Cell", + "Std.Data.Internal.Cut" + ] + }, + { + "module": "Std.Data.DTreeMap.Internal.WF.Lemmas", + "root": "lean", + "source_path": "src/lean/Std/Data/DTreeMap/Internal/WF/Lemmas.lean", + "source_sha256": "520836b4acac77fd3f0f3fdd60ef34313d591f1f9dbc54a2b5090898db181988", + "object_path": "lib/lean/Std/Data/DTreeMap/Internal/WF/Lemmas.olean", + "object_sha256": "22431ff2415ca03a2b50784d9f44d1830e768bfcf2ddfac8cb03999486cb1f3e", + "object_bytes": 4843056, + "imports": [ + "Init.Data.Option.List", + "Init.Data.Array.Bootstrap", + "Std.Classes.Ord.Basic", + "Std.Data.DTreeMap.Internal.Model", + "Std.Data.Internal.Cut", + "Std.Data.Internal.List.Associative" + ] + }, + { + "module": "Std.Data.DTreeMap.AdditionalOperations", + "root": "lean", + "source_path": "src/lean/Std/Data/DTreeMap/AdditionalOperations.lean", + "source_sha256": "cff8a8245cfb724cc9325dd1b668401ca6dd5ebf8939f7a179f1637b303f96b1", + "object_path": "lib/lean/Std/Data/DTreeMap/AdditionalOperations.olean", + "object_sha256": "136c27d2a5eb0ec6a8e4d5de491cbd2d8c78e44238dcac132598bdd3f9836943", + "object_bytes": 249800, + "imports": [ + "Std.Data.DTreeMap.Raw.Basic", + "Std.Data.DTreeMap.Internal.WF.Lemmas" + ] + }, + { + "module": "Std.Data.TreeMap.AdditionalOperations", + "root": "lean", + "source_path": "src/lean/Std/Data/TreeMap/AdditionalOperations.lean", + "source_sha256": "5826ac5cef3f14ef56835dbc5df2a8142aad149d2c83a27e6ad071059b5718cc", + "object_path": "lib/lean/Std/Data/TreeMap/AdditionalOperations.olean", + "object_sha256": "6ff7881c48f9e22395d1e339b93354a7245cf5eaf2796c9ae191f8865f3b80cb", + "object_bytes": 181528, + "imports": [ + "Std.Data.TreeMap.Basic", + "Std.Data.TreeMap.Raw.Basic", + "Std.Data.DTreeMap.AdditionalOperations" + ] + }, + { + "module": "Std.Data.DTreeMap.Internal.Lemmas", + "root": "lean", + "source_path": "src/lean/Std/Data/DTreeMap/Internal/Lemmas.lean", + "source_sha256": "2fe7a60543a275e55a625b78f632f687ddb1557d51481bb7c884f00728fc62be", + "object_path": "lib/lean/Std/Data/DTreeMap/Internal/Lemmas.olean", + "object_sha256": "ecc3d9651edc1a24aa4aa68d29caa358f9f7441f3ed95c1b5a3a4a48cacc444d", + "object_bytes": 6940992, + "imports": [ + "Std.Data.HashMap.Basic", + "Std.Data.DTreeMap.Internal.WF.Lemmas" + ] + }, + { + "module": "Std.Data.DTreeMap.Lemmas", + "root": "lean", + "source_path": "src/lean/Std/Data/DTreeMap/Lemmas.lean", + "source_sha256": "e838f85be3996dee58661277102f50095e0da78912ebd1867c0b5a4eebc051d5", + "object_path": "lib/lean/Std/Data/DTreeMap/Lemmas.olean", + "object_sha256": "a1189a054f4aeb302003f6052f3edcf17d4c68f877306b9c11ba9c75029e74b6", + "object_bytes": 2022528, + "imports": [ + "Std.Data.DTreeMap.Internal.Lemmas", + "Std.Data.DTreeMap.Basic" + ] + }, + { + "module": "Std.Data.TreeMap.Lemmas", + "root": "lean", + "source_path": "src/lean/Std/Data/TreeMap/Lemmas.lean", + "source_sha256": "af6bba407aaa0ea2bcfe45335046e0917eecec180c2c4364180bcb6ef83a837d", + "object_path": "lib/lean/Std/Data/TreeMap/Lemmas.olean", + "object_sha256": "30c015a65d2bab496f1a30e88100c8d7eb83ed056bfaa84d2d6af92b6c6ebfc6", + "object_bytes": 1443968, + "imports": [ + "Std.Data.DTreeMap.Lemmas", + "Std.Data.TreeMap.Basic" + ] + }, + { + "module": "Std.Data.TreeMap", + "root": "lean", + "source_path": "src/lean/Std/Data/TreeMap.lean", + "source_sha256": "4d27a0acf16c48077daecac9dbbf12a6206d00e95c4821234cee89120159fd93", + "object_path": "lib/lean/Std/Data/TreeMap.olean", + "object_sha256": "b2a4cfcaec5c335b31a2a6f37d3b629485f1a3aa132401091604f5726d382bd8", + "object_bytes": 18256, + "imports": [ + "Std.Data.TreeMap.Basic", + "Std.Data.TreeMap.AdditionalOperations", + "Std.Data.TreeMap.Lemmas" + ] + }, + { + "module": "Lean.Data.Lsp.Internal", + "root": "lean", + "source_path": "src/lean/Lean/Data/Lsp/Internal.lean", + "source_sha256": "1fb996b2817fcc3ac51091b7b7be92b52e06c17c921c57d009053f23014faa1a", + "object_path": "lib/lean/Lean/Data/Lsp/Internal.olean", + "object_sha256": "cd499b85a0597ba00406d98fba3f805a4e231b74d32e94265ba109eb86e17b07", + "object_bytes": 1432776, + "imports": [ + "Lean.Expr", + "Lean.Data.Lsp.Basic", + "Lean.Data.JsonRpc", + "Std.Data.TreeMap" + ] + }, + { + "module": "Lean.Data.Lsp.Ipc", + "root": "lean", + "source_path": "src/lean/Lean/Data/Lsp/Ipc.lean", + "source_sha256": "3a7ae822cafdf9327235ab83c1ed106756096c387c95a05813a5757192185d57", + "object_path": "lib/lean/Lean/Data/Lsp/Ipc.olean", + "object_sha256": "953fb69484af083f2a904a6fd0b44587863c51553a54c44989060dfda39b8bc5", + "object_bytes": 429872, + "imports": [ + "Init.System.IO", + "Lean.Data.Json", + "Lean.Data.Lsp.Communication", + "Lean.Data.Lsp.Diagnostics", + "Lean.Data.Lsp.Extra" + ] + }, + { + "module": "Lean.Data.Lsp.Window", + "root": "lean", + "source_path": "src/lean/Lean/Data/Lsp/Window.lean", + "source_sha256": "0c911b82dc010df8dcab2c8312ed489a088a503085e41897b21292dd9600f621", + "object_path": "lib/lean/Lean/Data/Lsp/Window.olean", + "object_sha256": "fba7dd3d2f9acb2aec8b80667d2b8691b1769c2db193c92fddc21c0b1f566b94", + "object_bytes": 321768, + "imports": [ + "Lean.Data.Json" + ] + }, + { + "module": "Lean.Data.Lsp", + "root": "lean", + "source_path": "src/lean/Lean/Data/Lsp.lean", + "source_sha256": "db8e490e482b07944ce3dd8f5222da24bed179b8c32292fc7b94722aa1816a82", + "object_path": "lib/lean/Lean/Data/Lsp.olean", + "object_sha256": "ea9515e085b822b23f296a3d68b6e41acf14632427772d90d54ffebb3a0b2c5c", + "object_bytes": 19608, + "imports": [ + "Lean.Data.Lsp.Basic", + "Lean.Data.Lsp.CancelParams", + "Lean.Data.Lsp.Capabilities", + "Lean.Data.Lsp.Client", + "Lean.Data.Lsp.Communication", + "Lean.Data.Lsp.Diagnostics", + "Lean.Data.Lsp.Extra", + "Lean.Data.Lsp.InitShutdown", + "Lean.Data.Lsp.Internal", + "Lean.Data.Lsp.LanguageFeatures", + "Lean.Data.Lsp.TextSync", + "Lean.Data.Lsp.Utf16", + "Lean.Data.Lsp.Workspace", + "Lean.Data.Lsp.Ipc", + "Lean.Data.Lsp.CodeActions", + "Lean.Data.Lsp.Window" + ] + }, + { + "module": "Lean.Data.Trie", + "root": "lean", + "source_path": "src/lean/Lean/Data/Trie.lean", + "source_sha256": "41de2f8d21c3099c7e3732fb8b5dc8314975e09177d73a49be32c65d7cf0d80f", + "object_path": "lib/lean/Lean/Data/Trie.olean", + "object_sha256": "0000d6eeaff3720a9f317f063f5be298fae8c514eabb2eb78bc608767100d1e3", + "object_bytes": 375336, + "imports": [ + "Lean.Data.Format", + "Init.Data.Option.Coe" + ] + }, + { + "module": "Lean.Data.Xml.Basic", + "root": "lean", + "source_path": "src/lean/Lean/Data/Xml/Basic.lean", + "source_sha256": "6fa3eb84233ec00dfb9459bdfed38b54f47c911f936e9d1a7ad26caad10e5a35", + "object_path": "lib/lean/Lean/Data/Xml/Basic.olean", + "object_sha256": "5f4d80400b55a456bad2a8a2c3a573c7b1305282bd8ab2561731127f74f576ad", + "object_bytes": 212160, + "imports": [ + "Lean.Data.RBMap", + "Init.Data.ToString.Macro" + ] + }, + { + "module": "Lean.Data.Xml.Parser", + "root": "lean", + "source_path": "src/lean/Lean/Data/Xml/Parser.lean", + "source_sha256": "69a767ae389c43e55aaa9895116f83bdc0acaa9924799e212d9c92037e9a78b4", + "object_path": "lib/lean/Lean/Data/Xml/Parser.olean", + "object_sha256": "afc3cb25a1beaf06b4f3f9a76d17dfbd65d50030fe2aed4e421a8fb19630b108", + "object_bytes": 1920696, + "imports": [ + "Std.Internal.Parsec", + "Lean.Data.Xml.Basic" + ] + }, + { + "module": "Lean.Data.Xml", + "root": "lean", + "source_path": "src/lean/Lean/Data/Xml.lean", + "source_sha256": "2918fd0c1cbe250fa735fa24b0aed5fbab6177b66135941bb902a584c0c98487", + "object_path": "lib/lean/Lean/Data/Xml.olean", + "object_sha256": "9db9691b6658925707f20e780429b807689253882d1c3b6e50605b835dfc48b3", + "object_bytes": 18024, + "imports": [ + "Lean.Data.Xml.Basic", + "Lean.Data.Xml.Parser" + ] + }, + { + "module": "Lean.Util.RecDepth", + "root": "lean", + "source_path": "src/lean/Lean/Util/RecDepth.lean", + "source_sha256": "5fe373b09102c7a5e67f6f505d156cd6dfac904cc5383067234c09c82c13f793", + "object_path": "lib/lean/Lean/Util/RecDepth.olean", + "object_sha256": "ba6d4ef9a9082b8a9073452e013fce644e1d2979f532bd0e88347c4ced4f6d09", + "object_bytes": 40848, + "imports": [ + "Lean.Data.Options" + ] + }, + { + "module": "Lean.Elab.Exception", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Exception.lean", + "source_sha256": "f3b6e00ece1dfbc28f9b8d76ca5eab65239aecde7765ad1657a46e8f76950fa7", + "object_path": "lib/lean/Lean/Elab/Exception.olean", + "object_sha256": "77759f0870cba0d1cd913e9bbac3dc24f1ae9d9919c0a979c9320e5d5aa01b8f", + "object_bytes": 108104, + "imports": [ + "Lean.InternalExceptionId", + "Lean.Exception" + ] + }, + { + "module": "Lean.Util.Trace", + "root": "lean", + "source_path": "src/lean/Lean/Util/Trace.lean", + "source_sha256": "8a05e345c88e1205cf6b7056bb0c8c2d3ff9850ff6bfd2489189cb383f896f66", + "object_path": "lib/lean/Lean/Util/Trace.olean", + "object_sha256": "751963bbd3cef5ff9f35bcaa3b549a091c6642f623c7b44aa107d07864fd5314", + "object_bytes": 1274152, + "imports": [ + "Lean.Elab.Exception", + "Lean.Log" + ] + }, + { + "module": "Lean.Modifiers", + "root": "lean", + "source_path": "src/lean/Lean/Modifiers.lean", + "source_sha256": "88385202459a839b81ab9b1ad48cc08ef6540bebd649029d2b0ee57c7c11e82b", + "object_path": "lib/lean/Lean/Modifiers.olean", + "object_sha256": "d791f183b5421dc4450e354b3daac9b0c70bb73fdddb3f17e5bd7e4315080bf5", + "object_bytes": 44856, + "imports": [ + "Lean.EnvExtension", + "Lean.PrivateName" + ] + }, + { + "module": "Lean.Namespace", + "root": "lean", + "source_path": "src/lean/Lean/Namespace.lean", + "source_sha256": "0511e03b4711544a426cecbf922eb311f463485a71581084419e3414aa29c0e8", + "object_path": "lib/lean/Lean/Namespace.olean", + "object_sha256": "85a5339129a78b4287979db656b1f2b740de2f0b34d71f768bc2497feab4ce5d", + "object_bytes": 160720, + "imports": [ + "Lean.EnvExtension" + ] + }, + { + "module": "Lean.ResolveName", + "root": "lean", + "source_path": "src/lean/Lean/ResolveName.lean", + "source_sha256": "22e0da95891a1cb651eef47b0e0b6cf778f631ffa39f0f1b3523668e9f996ba3", + "object_path": "lib/lean/Lean/ResolveName.olean", + "object_sha256": "7b584b6a1f21d08ec8933e28de6bb0bc9147faf3622108fe700f2533bdaa74eb", + "object_bytes": 1122288, + "imports": [ + "Lean.Data.OpenDecl", + "Lean.Hygiene", + "Lean.Modifiers", + "Lean.Exception", + "Lean.Namespace" + ] + }, + { + "module": "Lean.DocString.Links", + "root": "lean", + "source_path": "src/lean/Lean/DocString/Links.lean", + "source_sha256": "c5abb4c862604a90678e791cc6889b5781c23af73177bd56e165a4732b6bee41", + "object_path": "lib/lean/Lean/DocString/Links.olean", + "object_sha256": "325c9fcf821b93b989cd36dbffd8720b8a37a7ab7012a3d83a3bb65dcf76821e", + "object_bytes": 366712, + "imports": [ + "Lean.Syntax" + ] + }, + { + "module": "Lean.DocString.Extension", + "root": "lean", + "source_path": "src/lean/Lean/DocString/Extension.lean", + "source_sha256": "d5dff63e08be4980049a83819561ec26c52656b00c22b549aaeae2c068596b84", + "object_path": "lib/lean/Lean/DocString/Extension.olean", + "object_sha256": "7f1ba80b9cbe6325db540ae644ed575da9bdfdad0f9cc587df4b34aa16f6fbd8", + "object_bytes": 203896, + "imports": [ + "Lean.DeclarationRange", + "Lean.DocString.Links", + "Lean.MonadEnv", + "Init.Data.String.Extra" + ] + }, + { + "module": "Lean.Parser.Types", + "root": "lean", + "source_path": "src/lean/Lean/Parser/Types.lean", + "source_sha256": "21d45161c1edbd22522379db43fcfe287f5c06708ba4bcd9bad72f407ce08b42", + "object_path": "lib/lean/Lean/Parser/Types.olean", + "object_sha256": "d25f98bbc6578f4707623f6c430c3689c94824d3539ecd3fe054bc7199714661", + "object_bytes": 1127904, + "imports": [ + "Lean.Data.Trie", + "Lean.Syntax", + "Lean.Message", + "Lean.DocString.Extension" + ] + }, + { + "module": "Lean.Language.Basic", + "root": "lean", + "source_path": "src/lean/Lean/Language/Basic.lean", + "source_sha256": "d5aade4e72ccc96d7a5df3c35b57402b08b110784ce1a54c5edef554d847a5b3", + "object_path": "lib/lean/Lean/Language/Basic.olean", + "object_sha256": "e19a6505b6b87574f6001b19f521a284782f4989ca70c0113f506a47013fed35", + "object_bytes": 837448, + "imports": [ + "Init.System.Promise", + "Lean.Parser.Types", + "Lean.Util.Trace" + ] + }, + { + "module": "Lean.CoreM", + "root": "lean", + "source_path": "src/lean/Lean/CoreM.lean", + "source_sha256": "5b7b4b32959ecf3c55e1bb99b638e33ffa992e6eb097c8d3da36190b914fe894", + "object_path": "lib/lean/Lean/CoreM.olean", + "object_sha256": "87787025bb7727041684fdc1bbb984ee1cc0b674e102192c0b24833efe420047", + "object_bytes": 2698408, + "imports": [ + "Lean.Util.RecDepth", + "Lean.Util.Trace", + "Lean.Log", + "Lean.ResolveName", + "Lean.Elab.InfoTree.Types", + "Lean.MonadEnv", + "Lean.Elab.Exception", + "Lean.Language.Basic" + ] + }, + { + "module": "Lean.Attributes", + "root": "lean", + "source_path": "src/lean/Lean/Attributes.lean", + "source_sha256": "cd91cfaf8f44869a93b00b98905db7a4fb3ffb642a8fcde48822d6ae536cf125", + "object_path": "lib/lean/Lean/Attributes.olean", + "object_sha256": "e7e370f97a5bd98dfce160002124f5f06d9e86a6e969416595365d6a230eb8ab", + "object_bytes": 1412056, + "imports": [ + "Lean.CoreM", + "Lean.MonadEnv" + ] + }, + { + "module": "Lean.Class", + "root": "lean", + "source_path": "src/lean/Lean/Class.lean", + "source_sha256": "134583b019d372ae8f9387a7a4bcf9e63f5bcce2a5cc77dbe52f02c729e7528a", + "object_path": "lib/lean/Lean/Class.olean", + "object_sha256": "d24a4437677a2c1de518875daeefdb28a7d4b4f07e5662f058bbe47fb730f740", + "object_bytes": 517848, + "imports": [ + "Lean.Attributes" + ] + }, + { + "module": "Lean.ScopedEnvExtension", + "root": "lean", + "source_path": "src/lean/Lean/ScopedEnvExtension.lean", + "source_sha256": "85ba30e9831fe4e4f367e7281b31ace0233496f73bfc6ab83afa41c27c275950", + "object_path": "lib/lean/Lean/ScopedEnvExtension.olean", + "object_sha256": "1fdfd7374e200523c462ca7233780107f6b9059899ea6537cf49f7c1c30a35a7", + "object_bytes": 990344, + "imports": [ + "Lean.Environment", + "Lean.Data.NameTrie", + "Lean.Attributes" + ] + }, + { + "module": "Lean.ReducibilityAttrs", + "root": "lean", + "source_path": "src/lean/Lean/ReducibilityAttrs.lean", + "source_sha256": "c87a90718f6154a42e07c7ed8121100688baf569e53530cab784ca4fa555c940", + "object_path": "lib/lean/Lean/ReducibilityAttrs.olean", + "object_sha256": "06497853546eb547f4497e3cfb4ff4d7d048a988032c0587590487a1076ce002", + "object_bytes": 595288, + "imports": [ + "Lean.Attributes", + "Lean.ScopedEnvExtension" + ] + }, + { + "module": "Lean.Util.MonadBacktrack", + "root": "lean", + "source_path": "src/lean/Lean/Util/MonadBacktrack.lean", + "source_sha256": "ce2eaf2427e22572445bf6bcaba18abfad53318bc697528214c2ce27556a3e98", + "object_path": "lib/lean/Lean/Util/MonadBacktrack.olean", + "object_sha256": "6fc2952dc3574a2d764bab054a9fa34e92ccc8195aa51bc60233d9e7cfdb2fdf", + "object_bytes": 166064, + "imports": [ + "Init.Control.Except", + "Init.Data.Option.Coe" + ] + }, + { + "module": "Lean.Compiler.InlineAttrs", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/InlineAttrs.lean", + "source_sha256": "21832824b3dafa5d573af88fd32a2a597fca634aa608fe101af9344885f17d11", + "object_path": "lib/lean/Lean/Compiler/InlineAttrs.olean", + "object_sha256": "9465d3c57a6cfb09ff15afa2b39cf0c9681b5be281926f64478474adf4c2171c", + "object_bytes": 227496, + "imports": [ + "Lean.Attributes" + ] + }, + { + "module": "Lean.Meta.TransparencyMode", + "root": "lean", + "source_path": "src/lean/Lean/Meta/TransparencyMode.lean", + "source_sha256": "ba2c8d3e153525d807b67d5c15b91bb21aebb5f5506b754b04a3122b7867cb59", + "object_path": "lib/lean/Lean/Meta/TransparencyMode.olean", + "object_sha256": "cd9ad6794441fd9a59c72486a0ce6e8bdf08aa9960539ef157964fa309e15f83", + "object_bytes": 41688, + "imports": [ + "Init.Data.UInt.Basic" + ] + }, + { + "module": "Lean.Meta.Basic", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Basic.lean", + "source_sha256": "0b6e6909fef9ff0c26ca9433e1d856ed13df849e535502fc71459037a629882e", + "object_path": "lib/lean/Lean/Meta/Basic.olean", + "object_sha256": "b2a052cf055afb0a1ed03fffc013f110fe1b445441c9bf7aa206e1d31188bb67", + "object_bytes": 5964152, + "imports": [ + "Lean.Data.LOption", + "Lean.Environment", + "Lean.Class", + "Lean.ReducibilityAttrs", + "Lean.Util.ReplaceExpr", + "Lean.Util.MonadBacktrack", + "Lean.Compiler.InlineAttrs", + "Lean.Meta.TransparencyMode" + ] + }, + { + "module": "Lean.Meta.InferType", + "root": "lean", + "source_path": "src/lean/Lean/Meta/InferType.lean", + "source_sha256": "555acb14b4b732a1c0943f312bdb47289c3f20a4c02ef6c7edca853137ce8c0a", + "object_path": "lib/lean/Lean/Meta/InferType.olean", + "object_sha256": "2ab3f2b020b483cb08ec99c8256a6e7106066abf42729e00a21ecf24a0990691", + "object_bytes": 2276960, + "imports": [ + "Lean.Data.LBool", + "Lean.Meta.Basic" + ] + }, + { + "module": "Lean.Meta.DecLevel", + "root": "lean", + "source_path": "src/lean/Lean/Meta/DecLevel.lean", + "source_sha256": "0350828d8428020c7e23a6295049f57ff4b74cc4a5ef16d9885402e4a6b51d90", + "object_path": "lib/lean/Lean/Meta/DecLevel.olean", + "object_sha256": "05455c7d279a5a8313db581c41bfb75159367af0c934d7f5a8b6d3abb358d1ee", + "object_bytes": 248512, + "imports": [ + "Lean.Meta.Basic", + "Lean.Meta.InferType" + ] + }, + { + "module": "Lean.Data.RArray", + "root": "lean", + "source_path": "src/lean/Lean/Data/RArray.lean", + "source_sha256": "486e007dec14353191e4f22702e31ab4bbdce6a363dcce03a01926ef332c424f", + "object_path": "lib/lean/Lean/Data/RArray.olean", + "object_sha256": "665ddaae4e130fc7d62bcd448974f9f32331c0d5cde5e8f9ad3bac54ef669c48", + "object_bytes": 511024, + "imports": [ + "Init.Data.RArray", + "Lean.Meta.InferType", + "Lean.Meta.DecLevel", + "Lean.ToExpr" + ] + }, + { + "module": "Lean.Data", + "root": "lean", + "source_path": "src/lean/Lean/Data.lean", + "source_sha256": "6cc9a664545975b38b5e3b851ab1cb52cb653301cb7ded2a9b4f9f274dd3318e", + "object_path": "lib/lean/Lean/Data.olean", + "object_sha256": "f6b39aab302fdd473932f33d2d2b3ccfd231bb2020d46a6c3a64570fb5060d99", + "object_bytes": 20360, + "imports": [ + "Lean.Data.AssocList", + "Lean.Data.Format", + "Lean.Data.Json", + "Lean.Data.JsonRpc", + "Lean.Data.KVMap", + "Lean.Data.LBool", + "Lean.Data.LOption", + "Lean.Data.Lsp", + "Lean.Data.Name", + "Lean.Data.NameMap", + "Lean.Data.OpenDecl", + "Lean.Data.Options", + "Lean.Data.PersistentArray", + "Lean.Data.PersistentHashMap", + "Lean.Data.PersistentHashSet", + "Lean.Data.Position", + "Lean.Data.PrefixTree", + "Lean.Data.SMap", + "Lean.Data.Trie", + "Lean.Data.Xml", + "Lean.Data.NameTrie", + "Lean.Data.RBTree", + "Lean.Data.RBMap", + "Lean.Data.RArray" + ] + }, + { + "module": "Lean.Compiler.Specialize", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/Specialize.lean", + "source_sha256": "9f645ee6a65c08c4157327015a8c7c958f359f6af87fbbeb77cd4ce32afe24bf", + "object_path": "lib/lean/Lean/Compiler/Specialize.olean", + "object_sha256": "401db47fdf7d0d791201d62015e15eb629ccd0b899e19bfcb240a1b2f6936296", + "object_bytes": 748608, + "imports": [ + "Lean.Meta.Basic", + "Lean.Attributes" + ] + }, + { + "module": "Lean.Compiler.ConstFolding", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/ConstFolding.lean", + "source_sha256": "dbbe374a1d99e072a176c1cab1bac8c5d572941233f36006979b83187c48ffe9", + "object_path": "lib/lean/Lean/Compiler/ConstFolding.olean", + "object_sha256": "de439206188297c1a1dc6b31700fd89366dd2ab243a68d89e2f847abbd34fc4c", + "object_bytes": 522200, + "imports": [ + "Lean.Expr" + ] + }, + { + "module": "Lean.Compiler.ClosedTermCache", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/ClosedTermCache.lean", + "source_sha256": "0167f79bbb55926d9b5f044a6010d5224ab502c3cb994ae3c35b305eee664565", + "object_path": "lib/lean/Lean/Compiler/ClosedTermCache.olean", + "object_sha256": "74011d0c29c1c13d46a482dc8fa05126fd8c66c943636e4d06e86b107cd95531", + "object_bytes": 179776, + "imports": [ + "Lean.Environment" + ] + }, + { + "module": "Lean.ProjFns", + "root": "lean", + "source_path": "src/lean/Lean/ProjFns.lean", + "source_sha256": "05a6907c1f20eb48fe30809d66df6791830302d754a88638bb5e3ba87b55c1f3", + "object_path": "lib/lean/Lean/ProjFns.olean", + "object_sha256": "67e08a27e0e40e50e7118776dc64877eba965996bb71e81d6ac3ec7f26d01073", + "object_bytes": 170144, + "imports": [ + "Lean.EnvExtension" + ] + }, + { + "module": "Lean.Compiler.ExternAttr", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/ExternAttr.lean", + "source_sha256": "154ca785ced5b32d6052e6f2a95fcc30b0b48365967d16097fe83394a27b10ac", + "object_path": "lib/lean/Lean/Compiler/ExternAttr.olean", + "object_sha256": "386b6073c71fcf871650360125abfc41ecec9db64c285f4262d8130d67ab8697", + "object_bytes": 661752, + "imports": [ + "Init.Data.List.BasicAux", + "Lean.Expr", + "Lean.Environment", + "Lean.Attributes", + "Lean.ProjFns", + "Lean.Meta.Basic" + ] + }, + { + "module": "Lean.Meta.PPGoal", + "root": "lean", + "source_path": "src/lean/Lean/Meta/PPGoal.lean", + "source_sha256": "3d3e5f88e6d6cc33005cfa4dbd829516e2c6d7d814f9fe886cdf689efb5e6c45", + "object_path": "lib/lean/Lean/Meta/PPGoal.olean", + "object_sha256": "3b56eef4cf6cf71ab4182a6baf0a102e00d3c6b8cf9cdcb5167f6139c87b6af3", + "object_bytes": 406616, + "imports": [ + "Lean.Meta.InferType" + ] + }, + { + "module": "Lean.ReservedNameAction", + "root": "lean", + "source_path": "src/lean/Lean/ReservedNameAction.lean", + "source_sha256": "d68338949fe045b61500f965e264f6ad8f47c5aec0f1f213913dc44108409c96", + "object_path": "lib/lean/Lean/ReservedNameAction.olean", + "object_sha256": "a6d42ed5d398e50a2f2646f69fddc092df915c78f504be0329874a31dd924f68", + "object_bytes": 232984, + "imports": [ + "Lean.CoreM" + ] + }, + { + "module": "Lean.Elab.InfoTree.Main", + "root": "lean", + "source_path": "src/lean/Lean/Elab/InfoTree/Main.lean", + "source_sha256": "44aae0babe1583e7335e7a00a2f6e70ede679fad1850ccb93a81f75ca89c780a", + "object_path": "lib/lean/Lean/Elab/InfoTree/Main.olean", + "object_sha256": "4ca2cde86a4063bd2999ee59f03fa894ba3d8d640e04868de1d04c1927fdc29d", + "object_bytes": 1303544, + "imports": [ + "Init.Task", + "Lean.Meta.PPGoal", + "Lean.ReservedNameAction" + ] + }, + { + "module": "Lean.Elab.InfoTree", + "root": "lean", + "source_path": "src/lean/Lean/Elab/InfoTree.lean", + "source_sha256": "3bef6430c4f0600a3d9395a4d32ae972bc0d70aff659bac391fbd36d19fd3c52", + "object_path": "lib/lean/Lean/Elab/InfoTree.olean", + "object_sha256": "87d7c3631212ac187b829d687664db618c08730afa46e90ea11626789986e1d2", + "object_bytes": 18000, + "imports": [ + "Lean.Elab.InfoTree.Types", + "Lean.Elab.InfoTree.Main" + ] + }, + { + "module": "Lean.Compiler.ImplementedByAttr", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/ImplementedByAttr.lean", + "source_sha256": "5d27620d6b6ec58dd9c5f956fa4e4a4c60f2839a9a5c7f2dd5e650f072a4132b", + "object_path": "lib/lean/Lean/Compiler/ImplementedByAttr.olean", + "object_sha256": "8e202cde51169987d1017fb7ae995ae0158ff59c45ff31f290fedfb17bb73ac4", + "object_bytes": 166736, + "imports": [ + "Lean.Attributes", + "Lean.Declaration", + "Lean.MonadEnv", + "Lean.Elab.InfoTree" + ] + }, + { + "module": "Lean.Compiler.NeverExtractAttr", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/NeverExtractAttr.lean", + "source_sha256": "a0f81014beea305b423cefa1d951e7b7cd18af5e2740b62d7000def9bcf60d15", + "object_path": "lib/lean/Lean/Compiler/NeverExtractAttr.olean", + "object_sha256": "761cf3c67b5513f65f8e0e92d3147b1b448ec6a4676be78e6db9453057eb8848", + "object_bytes": 44296, + "imports": [ + "Lean.Environment", + "Lean.Attributes" + ] + }, + { + "module": "Lean.Compiler.IR.Basic", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/IR/Basic.lean", + "source_sha256": "0b569b3d5c111f636d430eabfa6589f48b7c0aee6269c1d11626e2ea5af107a4", + "object_path": "lib/lean/Lean/Compiler/IR/Basic.olean", + "object_sha256": "0c1fbeeab25f9b4915ea3391117c2fe911bdc3e24d1da71da45ac7bf5469aae3", + "object_bytes": 2319784, + "imports": [ + "Lean.Data.KVMap", + "Lean.Data.Name", + "Lean.Data.Format", + "Lean.Compiler.ExternAttr" + ] + }, + { + "module": "Lean.Compiler.IR.Format", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/IR/Format.lean", + "source_sha256": "1c4bd960fcc395b365595d290e73f98d4c2d6be8627a3ec74c902e9f9d82e494", + "object_path": "lib/lean/Lean/Compiler/IR/Format.olean", + "object_sha256": "2360c9015c76d4681f8da05f735fc5d37a5a3469a7a97e0e75271034e72bd72e", + "object_bytes": 504920, + "imports": [ + "Lean.Compiler.IR.Basic" + ] + }, + { + "module": "Lean.Compiler.IR.CompilerM", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/IR/CompilerM.lean", + "source_sha256": "44a0625be258c844d9e2cdb3868cfce15f5877e724b07f2f3ddd399f68397804", + "object_path": "lib/lean/Lean/Compiler/IR/CompilerM.olean", + "object_sha256": "8212fe5eec74ec16accf297ff03528c02c1bf0b675d425d69b5c9bc09a5e7e07", + "object_bytes": 436752, + "imports": [ + "Lean.Environment", + "Lean.Compiler.IR.Basic", + "Lean.Compiler.IR.Format" + ] + }, + { + "module": "Lean.Compiler.IR.FreeVars", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/IR/FreeVars.lean", + "source_sha256": "9761fd058dbe90ec47490ec26bcc8ea8d6e4ff5dd0eab0c4738c29279eb7f750", + "object_path": "lib/lean/Lean/Compiler/IR/FreeVars.olean", + "object_sha256": "b3de699a6279a56b3e1a87eac172179dde26a775e9fc031c36de33373d6e598d", + "object_bytes": 398280, + "imports": [ + "Lean.Compiler.IR.Basic" + ] + }, + { + "module": "Lean.Compiler.IR.NormIds", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/IR/NormIds.lean", + "source_sha256": "b51e2964ecbec628c92b4ed4ad80bdb5d1a6bc90e56a85463ac32b9b629639b9", + "object_path": "lib/lean/Lean/Compiler/IR/NormIds.olean", + "object_sha256": "94376a89014bd22b366e14be14f58bdf0a3d8172ca69219ef78ae47e4c3f9566", + "object_bytes": 496144, + "imports": [ + "Lean.Compiler.IR.Basic" + ] + }, + { + "module": "Lean.Compiler.IR.PushProj", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/IR/PushProj.lean", + "source_sha256": "a4725d3ed34284e57b471d6adb32d3b4c7e6df97dc9f2c9648d5769427c6007c", + "object_path": "lib/lean/Lean/Compiler/IR/PushProj.olean", + "object_sha256": "1c9dd7c39770d66b079b5f34dd8643db2ae85400a0a2f2292546cc2e6e491c4d", + "object_bytes": 295776, + "imports": [ + "Lean.Compiler.IR.Basic", + "Lean.Compiler.IR.FreeVars", + "Lean.Compiler.IR.NormIds" + ] + }, + { + "module": "Lean.Compiler.IR.ElimDeadVars", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/IR/ElimDeadVars.lean", + "source_sha256": "ac2c0e3708ecf30e8ada518107d8b9af740a93f3b3f114204511e2c9c23e8347", + "object_path": "lib/lean/Lean/Compiler/IR/ElimDeadVars.olean", + "object_sha256": "d0b5f983c4c82bde6733f73285bb211ab9888fa65f5779bba9f851b228bfb54d", + "object_bytes": 137040, + "imports": [ + "Lean.Compiler.IR.Basic", + "Lean.Compiler.IR.FreeVars" + ] + }, + { + "module": "Lean.Compiler.IR.SimpCase", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/IR/SimpCase.lean", + "source_sha256": "f2259404d6213023e68efed18260884b38101a551a09ef584725b5343df72acd", + "object_path": "lib/lean/Lean/Compiler/IR/SimpCase.olean", + "object_sha256": "19c8af1b13ef2fab670d8d7bfe40c8f8f729126d51e2c79a42496a7593e7e5d5", + "object_bytes": 212888, + "imports": [ + "Lean.Compiler.IR.Basic", + "Lean.Compiler.IR.Format" + ] + }, + { + "module": "Lean.Compiler.IR.LiveVars", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/IR/LiveVars.lean", + "source_sha256": "c53378e07d2808b8a66bd9cda7e7fd3bb9cc1ca61de251391cb7f13c714af8d1", + "object_path": "lib/lean/Lean/Compiler/IR/LiveVars.olean", + "object_sha256": "c3c1c9f907cf7279e9305b7fef00f09dfcffde55a06b49c78609f9893ab2d03a", + "object_bytes": 377840, + "imports": [ + "Lean.Compiler.IR.Basic", + "Lean.Compiler.IR.FreeVars" + ] + }, + { + "module": "Lean.Compiler.IR.ResetReuse", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/IR/ResetReuse.lean", + "source_sha256": "216aae744e938030078ef3b3669d42275e309ce75180d68140ca9ab94643605a", + "object_path": "lib/lean/Lean/Compiler/IR/ResetReuse.olean", + "object_sha256": "45039fcda4c0c382cc2c9aefd8ff8a5e6015eef403505590c0a8a3718e1de755", + "object_bytes": 605296, + "imports": [ + "Lean.Compiler.IR.Basic", + "Lean.Compiler.IR.LiveVars", + "Lean.Compiler.IR.Format" + ] + }, + { + "module": "Lean.Compiler.IR.Checker", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/IR/Checker.lean", + "source_sha256": "afb664540bb9a4c4517d383bd48507f4be621d2cf5e3830134b040e99863ed05", + "object_path": "lib/lean/Lean/Compiler/IR/Checker.olean", + "object_sha256": "b0b5d216ae66c318deb1bed67c7c08c0f68752ada96bb5d2d9b7e1a93bebee80", + "object_bytes": 652768, + "imports": [ + "Lean.Compiler.IR.CompilerM", + "Lean.Compiler.IR.Format" + ] + }, + { + "module": "Lean.Compiler.ExportAttr", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/ExportAttr.lean", + "source_sha256": "f372994921c0e8df9986d6f7f8d223bd0191fa8327abcf4ab4c81e8cd7169aec", + "object_path": "lib/lean/Lean/Compiler/ExportAttr.olean", + "object_sha256": "3ad83ff8a2075546cb63dd157d4d51a0b4bce0b8e9b3d56b2b679b978e233a67", + "object_bytes": 127872, + "imports": [ + "Lean.Attributes" + ] + }, + { + "module": "Lean.Compiler.IR.Borrow", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/IR/Borrow.lean", + "source_sha256": "9231367d229c7e6529ce449158897212586d02ec49b8e36a31139060f7dd7447", + "object_path": "lib/lean/Lean/Compiler/IR/Borrow.olean", + "object_sha256": "05a01b95a354aed6e8887c7fe36b808b7752b04dc3b97c04528c603bec9ebec2", + "object_bytes": 881104, + "imports": [ + "Lean.Compiler.ExportAttr", + "Lean.Compiler.IR.CompilerM", + "Lean.Compiler.IR.NormIds" + ] + }, + { + "module": "Lean.Runtime", + "root": "lean", + "source_path": "src/lean/Lean/Runtime.lean", + "source_sha256": "30922464a8e43c6667d3b7a1d386c1cefaf44ddc7027b9af3c7b9473202d93dc", + "object_path": "lib/lean/Lean/Runtime.olean", + "object_sha256": "f0a195332208f07a827c72f51fbfe7eac95f47f62235f0d3a1d27246090d6f19", + "object_bytes": 27760, + "imports": [ + "Init.Prelude" + ] + }, + { + "module": "Lean.Compiler.IR.Boxing", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/IR/Boxing.lean", + "source_sha256": "8c4252f096a650dacea9b346814c8a1ee51deee90be1aa4b17bba7625dc1c67b", + "object_path": "lib/lean/Lean/Compiler/IR/Boxing.olean", + "object_sha256": "bf57c3dd75c0bea7e5462575cf0c5da26ca68b1709722daabfdcecebd1dc32fb", + "object_bytes": 820096, + "imports": [ + "Lean.Runtime", + "Lean.Compiler.ClosedTermCache", + "Lean.Compiler.ExternAttr", + "Lean.Compiler.IR.Basic", + "Lean.Compiler.IR.CompilerM", + "Lean.Compiler.IR.FreeVars", + "Lean.Compiler.IR.ElimDeadVars", + "Lean.Data.AssocList" + ] + }, + { + "module": "Lean.Compiler.IR.RC", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/IR/RC.lean", + "source_sha256": "0323ec10909e50b71f6b0386e3bbd1afa5f9090b6fc49a60a6786ff533aeebfa", + "object_path": "lib/lean/Lean/Compiler/IR/RC.olean", + "object_sha256": "196470106be135b8728ed5c22df4ee0ec8eb21ae58cabc4d737d430e7a73e525", + "object_bytes": 668536, + "imports": [ + "Lean.Runtime", + "Lean.Compiler.IR.CompilerM", + "Lean.Compiler.IR.LiveVars" + ] + }, + { + "module": "Lean.Compiler.IR.ExpandResetReuse", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/IR/ExpandResetReuse.lean", + "source_sha256": "252667d39ded326db791ed23fb967155e01da0165c695b0947cd2de1c4f32d26", + "object_path": "lib/lean/Lean/Compiler/IR/ExpandResetReuse.olean", + "object_sha256": "2521817464bc62e355b9a1722a4aec5574d4864647cc6e76a3bfe4be56db3a0d", + "object_bytes": 829368, + "imports": [ + "Lean.Compiler.IR.CompilerM", + "Lean.Compiler.IR.NormIds", + "Lean.Compiler.IR.FreeVars" + ] + }, + { + "module": "Lean.Compiler.IR.UnboxResult", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/IR/UnboxResult.lean", + "source_sha256": "9a9e8e47d902baf868d3ae38a419287fb45f0f1ca450a190b10eb185a323ce85", + "object_path": "lib/lean/Lean/Compiler/IR/UnboxResult.olean", + "object_sha256": "fc0ed893ee44ca0609e202e60f2de6566983f4031c09189b37fb1a49b536f876", + "object_bytes": 79648, + "imports": [ + "Lean.Data.Format", + "Lean.Compiler.IR.Basic" + ] + }, + { + "module": "Lean.Compiler.IR.ElimDeadBranches", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/IR/ElimDeadBranches.lean", + "source_sha256": "26078c8d24e5a0c2949e39482fb3000572cc7d979ff960fe3a5806fb495cd85a", + "object_path": "lib/lean/Lean/Compiler/IR/ElimDeadBranches.olean", + "object_sha256": "bb3cf561e22569b936bba431e19b7ea73dbac5cdafc906a3c68446648b57e240", + "object_bytes": 1290216, + "imports": [ + "Lean.Compiler.IR.Format", + "Lean.Compiler.IR.Basic", + "Lean.Compiler.IR.CompilerM" + ] + }, + { + "module": "Lean.Compiler.NameMangling", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/NameMangling.lean", + "source_sha256": "2b35e6889a9a4abdb1db393b9a644243112ed8626eb994d7430899a61bebab48", + "object_path": "lib/lean/Lean/Compiler/NameMangling.olean", + "object_sha256": "91c2b890a286ada9fa21d2a1446c7e6b2b76cc236adf313b5199a0e3ae028a62", + "object_bytes": 141496, + "imports": [ + "Lean.Data.Name" + ] + }, + { + "module": "Lean.Util.CollectAxioms", + "root": "lean", + "source_path": "src/lean/Lean/Util/CollectAxioms.lean", + "source_sha256": "99ac852cc961896a178cb65dd8ffa7cb8d9dbae84d7e0b768babddbd36923274", + "object_path": "lib/lean/Lean/Util/CollectAxioms.olean", + "object_sha256": "b0d44353474b3cd1f6efc7ebc7d5f7e2fc6e253f8bc05b788d1720b08210c6ee", + "object_bytes": 182600, + "imports": [ + "Lean.MonadEnv", + "Lean.Util.FoldConsts" + ] + }, + { + "module": "Lean.AddDecl", + "root": "lean", + "source_path": "src/lean/Lean/AddDecl.lean", + "source_sha256": "88593ae5fb4b913a1b7b85e2984b7fd8308f5587f066a383b68e04ce9d0a3949", + "object_path": "lib/lean/Lean/AddDecl.olean", + "object_sha256": "6e2f973fd8747fff06264be8034796fdc84a83dfa4c84df4b21f6314787e4b08", + "object_bytes": 695832, + "imports": [ + "Lean.CoreM", + "Lean.Namespace", + "Lean.Util.CollectAxioms" + ] + }, + { + "module": "Lean.Compiler.InitAttr", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/InitAttr.lean", + "source_sha256": "eab8e5e919ea6d079855f34c62c53cd45920910303911c436661ce8301d0ddd3", + "object_path": "lib/lean/Lean/Compiler/InitAttr.olean", + "object_sha256": "de99e04e0b6e2724eee3125a17b682ab22fa0019f7cff266f9231db5a1137baa", + "object_bytes": 441472, + "imports": [ + "Lean.AddDecl", + "Lean.MonadEnv", + "Lean.Elab.InfoTree.Main" + ] + }, + { + "module": "Lean.Compiler.IR.EmitUtil", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/IR/EmitUtil.lean", + "source_sha256": "433fcdef747702cc2b698a35dd8e2344f7a2a4af294a5a58677b827328ea814d", + "object_path": "lib/lean/Lean/Compiler/IR/EmitUtil.olean", + "object_sha256": "1a44cd7f1961b073419e070f598ac9a534abc95bbc7550304bb66a59bef42e7e", + "object_bytes": 407064, + "imports": [ + "Lean.Compiler.InitAttr", + "Lean.Compiler.IR.CompilerM" + ] + }, + { + "module": "Lean.Compiler.IR.EmitC", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/IR/EmitC.lean", + "source_sha256": "4f7d11d1afb62e232e61d2765dd0efab825214e7a17797129d8236b21517e4c7", + "object_path": "lib/lean/Lean/Compiler/IR/EmitC.olean", + "object_sha256": "de8075c82dc5c5b16523b5a82ed0fcb2876c2a6ad840ef0b0daca14682b2355c", + "object_bytes": 1583032, + "imports": [ + "Lean.Runtime", + "Lean.Compiler.NameMangling", + "Lean.Compiler.ExportAttr", + "Lean.Compiler.InitAttr", + "Lean.Compiler.IR.CompilerM", + "Lean.Compiler.IR.EmitUtil", + "Lean.Compiler.IR.NormIds", + "Lean.Compiler.IR.SimpCase", + "Lean.Compiler.IR.Boxing" + ] + }, + { + "module": "Lean.Compiler.IR.CtorLayout", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/IR/CtorLayout.lean", + "source_sha256": "f6b75fb37f4deaf151cd257fb5ed9a4861dd96b4a9816049688bca690266bead", + "object_path": "lib/lean/Lean/Compiler/IR/CtorLayout.olean", + "object_sha256": "cbfa84a31ffd808a890e3fd8d33beacef5af6458d9efc5bc39dcb652ddf06e62", + "object_bytes": 145896, + "imports": [ + "Lean.Environment", + "Lean.Compiler.IR.Format" + ] + }, + { + "module": "Lean.Compiler.IR.Sorry", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/IR/Sorry.lean", + "source_sha256": "e4d56fced9aba20e4b8bbf182dcc30f73a5399a88cca91f496afb9ea3aac444b", + "object_path": "lib/lean/Lean/Compiler/IR/Sorry.olean", + "object_sha256": "999b1aa34c2f2803ef8a8c1726aecf5310667d238adc5a7d5f16279feb093984", + "object_bytes": 279312, + "imports": [ + "Lean.Compiler.IR.CompilerM" + ] + }, + { + "module": "Lean.Meta.GlobalInstances", + "root": "lean", + "source_path": "src/lean/Lean/Meta/GlobalInstances.lean", + "source_sha256": "65c2cc4285f3c07f2b6caca5bdb819bc6a2c974648ea6ec3e9addbcc7b3f5df2", + "object_path": "lib/lean/Lean/Meta/GlobalInstances.olean", + "object_sha256": "66582f217822067b03fba6039402e3f31de8037aec10e531ba6a17f1364258ac", + "object_bytes": 71600, + "imports": [ + "Lean.Meta.Basic", + "Lean.ScopedEnvExtension" + ] + }, + { + "module": "Lean.Structure", + "root": "lean", + "source_path": "src/lean/Lean/Structure.lean", + "source_sha256": "9ee44f7c6291063197286e90decf0d05af40a796dbecc7f868cb782939de4f14", + "object_path": "lib/lean/Lean/Structure.olean", + "object_sha256": "5ab66f1dadb8a9007baa6c3408721942263328bc50a21d2453b1017e74e3cea5", + "object_bytes": 1231920, + "imports": [ + "Init.Control.Option", + "Lean.Environment", + "Lean.ProjFns", + "Lean.Exception" + ] + }, + { + "module": "Lean.Util.Recognizers", + "root": "lean", + "source_path": "src/lean/Lean/Util/Recognizers.lean", + "source_sha256": "9c3a232247b381b98b2f36ad4705083da184ed7fa0cae00ca033289da4d58ee8", + "object_path": "lib/lean/Lean/Util/Recognizers.olean", + "object_sha256": "4607463ce9b755c2987a68b34b0d578f166f80f5b352de6b4b62cbf0c334de54", + "object_bytes": 1519040, + "imports": [ + "Lean.Environment" + ] + }, + { + "module": "Lean.Util.SafeExponentiation", + "root": "lean", + "source_path": "src/lean/Lean/Util/SafeExponentiation.lean", + "source_sha256": "a5fef605026f5fe3a933dc4cedfed40332bc0da1e87531f51d5021d4430c4218", + "object_path": "lib/lean/Lean/Util/SafeExponentiation.olean", + "object_sha256": "4801f3da2038cf9c976304e8b7e83ed255ca011dfb72b13b0b60cbf706e0aa8b", + "object_bytes": 74392, + "imports": [ + "Lean.CoreM" + ] + }, + { + "module": "Lean.Meta.GetUnfoldableConst", + "root": "lean", + "source_path": "src/lean/Lean/Meta/GetUnfoldableConst.lean", + "source_sha256": "3bac803f7dcf03b23628ff392ef806c0039f9494a175073ed15e1c102cea9997", + "object_path": "lib/lean/Lean/Meta/GetUnfoldableConst.olean", + "object_sha256": "4a8dfb66d739347e59dd4efcdda0e8e326e2f4516b464c4039dd25f7bf9b9df8", + "object_bytes": 147576, + "imports": [ + "Lean.Meta.GlobalInstances" + ] + }, + { + "module": "Lean.Meta.FunInfo", + "root": "lean", + "source_path": "src/lean/Lean/Meta/FunInfo.lean", + "source_sha256": "7e380432871d09ba6797d409c12853cbbd19f825479908c9732513c69e553a1d", + "object_path": "lib/lean/Lean/Meta/FunInfo.olean", + "object_sha256": "4b4324fdf1579eecd20ec84828993a969b5bc587b6e26d539af74ec18b4160f2", + "object_bytes": 526128, + "imports": [ + "Lean.Meta.Basic", + "Lean.Meta.InferType" + ] + }, + { + "module": "Lean.Meta.NatInstTesters", + "root": "lean", + "source_path": "src/lean/Lean/Meta/NatInstTesters.lean", + "source_sha256": "09437d4af424a23ac84af0bbd0c6c2987e50145e567150cb4523e2b5d999fd99", + "object_path": "lib/lean/Lean/Meta/NatInstTesters.olean", + "object_sha256": "9c12da84c33a887556bf30de4d2ef16fd56326ddff0be4aebdfb1722cf864402", + "object_bytes": 171064, + "imports": [ + "Lean.Meta.Basic" + ] + }, + { + "module": "Lean.Meta.Offset", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Offset.lean", + "source_sha256": "23836f824a60b1151cd0bdf247320878b6565137747e88c43c3bc73718285486", + "object_path": "lib/lean/Lean/Meta/Offset.olean", + "object_sha256": "4bdcbdac38f0bd797e840388c417f2fa6f7b79a40bd1dee0e60e0bb30ee4cfe7", + "object_bytes": 631064, + "imports": [ + "Init.Control.Option", + "Lean.Data.LBool", + "Lean.Meta.InferType", + "Lean.Meta.NatInstTesters", + "Lean.Util.SafeExponentiation" + ] + }, + { + "module": "Lean.Meta.LitValues", + "root": "lean", + "source_path": "src/lean/Lean/Meta/LitValues.lean", + "source_sha256": "68be2ff3b1e46a830b94207b3d2581f46f3c14bf9d6ed2e2f3b9aede970eb0d2", + "object_path": "lib/lean/Lean/Meta/LitValues.olean", + "object_sha256": "18e76271466d516e0e6470fea58b8036a5346d90af4e9410051d2ce90f1f8206", + "object_bytes": 665904, + "imports": [ + "Lean.Meta.Basic", + "Init.Control.Option" + ] + }, + { + "module": "Lean.Meta.CtorRecognizer", + "root": "lean", + "source_path": "src/lean/Lean/Meta/CtorRecognizer.lean", + "source_sha256": "d7121b7dd54d0326296afc8e67c9957d114789581272684d4f5ae42786d2b919", + "object_path": "lib/lean/Lean/Meta/CtorRecognizer.olean", + "object_sha256": "4b0c069fb39a48df055c13f4cd35b30df3354c75410161fee4c300082c9869a6", + "object_bytes": 253624, + "imports": [ + "Lean.Meta.LitValues", + "Lean.Meta.Offset" + ] + }, + { + "module": "Lean.Meta.Match.MatcherInfo", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Match/MatcherInfo.lean", + "source_sha256": "8a11751e05276b9a16ab6beae9d66ec9e8b07c29a6d49e120c2af5b0dff380ab", + "object_path": "lib/lean/Lean/Meta/Match/MatcherInfo.olean", + "object_sha256": "6e6c9db2317643229642d48f5d6bddb1b530ec259ef6af2656f005ed449e2b85", + "object_bytes": 397560, + "imports": [ + "Lean.Meta.Basic" + ] + }, + { + "module": "Lean.Meta.Match.MatchPatternAttr", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Match/MatchPatternAttr.lean", + "source_sha256": "0760693f44e1a126f25476c7ff7cfea0dc00a855b3e5ae1b5cbd4278cf638de6", + "object_path": "lib/lean/Lean/Meta/Match/MatchPatternAttr.olean", + "object_sha256": "16d1f36446b826a2b98536f18bcdafc905b07df54300dc99d3ae840988f1e90c", + "object_bytes": 38904, + "imports": [ + "Lean.Attributes" + ] + }, + { + "module": "Lean.Meta.Transform", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Transform.lean", + "source_sha256": "fe7fd07002c1d763c4fda87a16d0b95d4bba162d948c1ab8fdda2b8ea8b422bd", + "object_path": "lib/lean/Lean/Meta/Transform.olean", + "object_sha256": "eae659f021501e85074e9085c6565e1e578805d3ccf636ed18235f085199d6a6", + "object_bytes": 1354472, + "imports": [ + "Lean.Meta.Basic" + ] + }, + { + "module": "Lean.Meta.WHNF", + "root": "lean", + "source_path": "src/lean/Lean/Meta/WHNF.lean", + "source_sha256": "5274879c361de087076400f5ede24ba5459e417700524749fe6c134a3678c230", + "object_path": "lib/lean/Lean/Meta/WHNF.olean", + "object_sha256": "815d2627ca901bbea7025ed7d7d4bfb308be79f7cec6e9ccd47e5cc5d8f9c8d4", + "object_bytes": 3270664, + "imports": [ + "Lean.Structure", + "Lean.Util.Recognizers", + "Lean.Util.SafeExponentiation", + "Lean.Meta.GetUnfoldableConst", + "Lean.Meta.FunInfo", + "Lean.Meta.Offset", + "Lean.Meta.CtorRecognizer", + "Lean.Meta.Match.MatcherInfo", + "Lean.Meta.Match.MatchPatternAttr", + "Lean.Meta.Transform" + ] + }, + { + "module": "Lean.Meta.DiscrTreeTypes", + "root": "lean", + "source_path": "src/lean/Lean/Meta/DiscrTreeTypes.lean", + "source_sha256": "d13173cb3f8a039b403b6018c6c23655ad704920e4a9ba5af2f4f26611bde750", + "object_path": "lib/lean/Lean/Meta/DiscrTreeTypes.olean", + "object_sha256": "82d00fd33d2a86cbcd31a599a03af910d179e44c7930ce8f60928f95f658b134", + "object_bytes": 391840, + "imports": [ + "Lean.Expr", + "Lean.ToExpr" + ] + }, + { + "module": "Lean.Meta.DiscrTree", + "root": "lean", + "source_path": "src/lean/Lean/Meta/DiscrTree.lean", + "source_sha256": "27ca35834fffe27eaf56e79adf4706dc3cf07c20dff29236c59b7427ad705881", + "object_path": "lib/lean/Lean/Meta/DiscrTree.olean", + "object_sha256": "c5c3b1c06560cb2062bcb7ef4fa88910dcd60073140464714a1717ab935d744d", + "object_bytes": 2361248, + "imports": [ + "Lean.Meta.WHNF", + "Lean.Meta.Transform", + "Lean.Meta.DiscrTreeTypes" + ] + }, + { + "module": "Lean.Util.CollectMVars", + "root": "lean", + "source_path": "src/lean/Lean/Util/CollectMVars.lean", + "source_sha256": "be627a20627b33c3790b51a5571a315a6c400cb151f953477d7a3517ca5994d3", + "object_path": "lib/lean/Lean/Util/CollectMVars.olean", + "object_sha256": "d680375ab9df5ff9967aafe90389b4380c0808f925f78c5ef4bbbc74c32f3957", + "object_bytes": 158992, + "imports": [ + "Lean.Expr" + ] + }, + { + "module": "Lean.Meta.CollectMVars", + "root": "lean", + "source_path": "src/lean/Lean/Meta/CollectMVars.lean", + "source_sha256": "c4b12bb3ca0c13d293f7181c9ce34a7e236b156a672addf1acfadf7bd3435998", + "object_path": "lib/lean/Lean/Meta/CollectMVars.olean", + "object_sha256": "4cb886779ef8f53be579a2779db839b298329217da9cf66c732fc5be2839915f", + "object_bytes": 455120, + "imports": [ + "Lean.Util.CollectMVars", + "Lean.Meta.Basic" + ] + }, + { + "module": "Lean.Meta.Instances", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Instances.lean", + "source_sha256": "d7de4b328d437663d8c79f802d4b13a7832f3bb01ba629400344bf476bda63ee", + "object_path": "lib/lean/Lean/Meta/Instances.olean", + "object_sha256": "fd7b4c8e504adda0a7ec45e9dbaa677ac183e0b950ae6c1aeb1f2e3fbdf5d3f8", + "object_bytes": 1410736, + "imports": [ + "Lean.ScopedEnvExtension", + "Lean.Meta.GlobalInstances", + "Lean.Meta.DiscrTree", + "Lean.Meta.CollectMVars" + ] + }, + { + "module": "Lean.Compiler.BorrowedAnnotation", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/BorrowedAnnotation.lean", + "source_sha256": "55501f6673444ec0fe05ec9d936e02d6febd75ad9560a6da964201fa8e018729", + "object_path": "lib/lean/Lean/Compiler/BorrowedAnnotation.olean", + "object_sha256": "b96aeec69107452ab04ea1919daf780612a6310072451d0dc2246aa7b7e083f5", + "object_bytes": 27688, + "imports": [ + "Lean.Expr" + ] + }, + { + "module": "Lean.Compiler.LCNF.Types", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/Types.lean", + "source_sha256": "8e84d1e3d1e9896bbc32528ff5b8d238c0197f5e2157b907471dc4d5c0da9ca3", + "object_path": "lib/lean/Lean/Compiler/LCNF/Types.olean", + "object_sha256": "0bb29756d66f2d6bf929c3228843064e03e60bf8fbe8e67f37d57e6c48bdf42b", + "object_bytes": 793536, + "imports": [ + "Lean.Compiler.BorrowedAnnotation", + "Lean.Meta.InferType" + ] + }, + { + "module": "Lean.Compiler.LCNF.Basic", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/Basic.lean", + "source_sha256": "546b498dd0d1942fd11275ee48cac736c2750e16eff494724ab21389b13cd669", + "object_path": "lib/lean/Lean/Compiler/LCNF/Basic.olean", + "object_sha256": "729ab7b5637fac79782525fe22245f926387a0c821f051a894581f1b2ecec989", + "object_bytes": 1923872, + "imports": [ + "Init.Data.List.BasicAux", + "Lean.Expr", + "Lean.Meta.Instances", + "Lean.Compiler.ExternAttr", + "Lean.Compiler.InlineAttrs", + "Lean.Compiler.Specialize", + "Lean.Compiler.LCNF.Types" + ] + }, + { + "module": "Lean.Compiler.LCNF.LCtx", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/LCtx.lean", + "source_sha256": "d06f6cde410e5990e73378bc15431a0fea448efc2898d36a58d8792f8626fa6b", + "object_path": "lib/lean/Lean/Compiler/LCNF/LCtx.olean", + "object_sha256": "f8f5dba212a8b62b245608fa57bbbd7e2baab4debf5f18f2d5eff5e761164724", + "object_bytes": 427576, + "imports": [ + "Lean.LocalContext", + "Lean.Compiler.LCNF.Basic" + ] + }, + { + "module": "Lean.Compiler.LCNF.ConfigOptions", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/ConfigOptions.lean", + "source_sha256": "63d924b48eeef3516b00dd5ec429a723b223b4d0cb81f17b4acdc91478428a46", + "object_path": "lib/lean/Lean/Compiler/LCNF/ConfigOptions.olean", + "object_sha256": "2c3a00a242fb8ace116828a2180aff543d62404662c9b09ff0df347df70197d4", + "object_bytes": 119880, + "imports": [ + "Lean.Data.Options" + ] + }, + { + "module": "Lean.Compiler.LCNF.CompilerM", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/CompilerM.lean", + "source_sha256": "bf59c4ef321a095536f12dda6475e208737aaf059e23feb79fabad296cad8b64", + "object_path": "lib/lean/Lean/Compiler/LCNF/CompilerM.olean", + "object_sha256": "cd6ba75151709af6c53d7053f10eea26733b0792ef5657eeb1599e86cc9acad1", + "object_bytes": 1293464, + "imports": [ + "Lean.CoreM", + "Lean.Compiler.LCNF.Basic", + "Lean.Compiler.LCNF.LCtx", + "Lean.Compiler.LCNF.ConfigOptions" + ] + }, + { + "module": "Lean.Compiler.LCNF.PassManager", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/PassManager.lean", + "source_sha256": "2e069aede0afe37d58c1eb3c0aa476f45f487f69e7c38eead8617a134792f2b9", + "object_path": "lib/lean/Lean/Compiler/LCNF/PassManager.olean", + "object_sha256": "8653c156316c547433254ed04821c35bde028638ec5c90cced362d211d983c45", + "object_bytes": 434240, + "imports": [ + "Lean.Attributes", + "Lean.Environment", + "Lean.Meta.Basic", + "Lean.Compiler.LCNF.CompilerM" + ] + }, + { + "module": "Lean.Compiler.LCNF.PhaseExt", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/PhaseExt.lean", + "source_sha256": "e8d186d97f684a2a343905ffc3c4281501e0bdc9d1c8d108983d83cc1149cb6c", + "object_path": "lib/lean/Lean/Compiler/LCNF/PhaseExt.olean", + "object_sha256": "379602c34917ae12a408cd3e06ab4ea6df84b49f753247a9da237f25b4c6baca", + "object_bytes": 421968, + "imports": [ + "Lean.Compiler.LCNF.PassManager" + ] + }, + { + "module": "Lean.Compiler.IR.ToIR", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/IR/ToIR.lean", + "source_sha256": "208023f8e50c5a6e768c82c9c3946cc5a3f759dbc4602f68198a6a4e1ed8ef87", + "object_path": "lib/lean/Lean/Compiler/IR/ToIR.olean", + "object_sha256": "35b6c153072225148391ad24d878fb0d9444e2ec4c060332856bdbb9cf811751", + "object_bytes": 2343776, + "imports": [ + "Lean.Compiler.LCNF.Basic", + "Lean.Compiler.LCNF.CompilerM", + "Lean.Compiler.LCNF.PhaseExt", + "Lean.Compiler.IR.Basic", + "Lean.Compiler.IR.CompilerM", + "Lean.Compiler.IR.CtorLayout", + "Lean.CoreM", + "Lean.Environment" + ] + }, + { + "module": "Lean.Compiler.IR.LLVMBindings", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/IR/LLVMBindings.lean", + "source_sha256": "10d8eb609e568ddd160552a9006f94bb7762a64a340e402e7bf4c6153fc1428d", + "object_path": "lib/lean/Lean/Compiler/IR/LLVMBindings.olean", + "object_sha256": "94ef7e784b65b1a97ae364cc0b3215339f4e42db7beee61b5c27ba592f0a8c0b", + "object_bytes": 483120, + "imports": [ + "Init.System.IO" + ] + }, + { + "module": "Lean.Compiler.IR.EmitLLVM", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/IR/EmitLLVM.lean", + "source_sha256": "248cc53083664e0cc7f8bcba0fed6d1821e26aded52e450d2fbad13dd477ebdf", + "object_path": "lib/lean/Lean/Compiler/IR/EmitLLVM.olean", + "object_sha256": "a94054056ba8de68462212d704626f39f12d9349b5d3678f55daf0979187ec39", + "object_bytes": 4477488, + "imports": [ + "Lean.Runtime", + "Lean.Compiler.NameMangling", + "Lean.Compiler.ExportAttr", + "Lean.Compiler.InitAttr", + "Lean.Compiler.IR.CompilerM", + "Lean.Compiler.IR.EmitUtil", + "Lean.Compiler.IR.NormIds", + "Lean.Compiler.IR.SimpCase", + "Lean.Compiler.IR.Boxing", + "Lean.Compiler.IR.ResetReuse", + "Lean.Compiler.IR.LLVMBindings" + ] + }, + { + "module": "Lean.Compiler.IR", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/IR.lean", + "source_sha256": "4dcb1512435c316d9a52b3afe6e70be0fae5975c077c245a4ff2f82cb2210520", + "object_path": "lib/lean/Lean/Compiler/IR.olean", + "object_sha256": "425b6bd5c8d8cc8eaaa39d70c1211c5f385843a99b9460e908b35960b9e89dd0", + "object_bytes": 180600, + "imports": [ + "Lean.Compiler.IR.Basic", + "Lean.Compiler.IR.Format", + "Lean.Compiler.IR.CompilerM", + "Lean.Compiler.IR.PushProj", + "Lean.Compiler.IR.ElimDeadVars", + "Lean.Compiler.IR.SimpCase", + "Lean.Compiler.IR.ResetReuse", + "Lean.Compiler.IR.NormIds", + "Lean.Compiler.IR.Checker", + "Lean.Compiler.IR.Borrow", + "Lean.Compiler.IR.Boxing", + "Lean.Compiler.IR.RC", + "Lean.Compiler.IR.ExpandResetReuse", + "Lean.Compiler.IR.UnboxResult", + "Lean.Compiler.IR.ElimDeadBranches", + "Lean.Compiler.IR.EmitC", + "Lean.Compiler.IR.CtorLayout", + "Lean.Compiler.IR.Sorry", + "Lean.Compiler.IR.ToIR", + "Lean.Compiler.IR.LLVMBindings", + "Lean.Compiler.IR.EmitLLVM" + ] + }, + { + "module": "Lean.Compiler.CSimpAttr", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/CSimpAttr.lean", + "source_sha256": "07bfcaada2beee61c2517bbd9cfcd0e50ebd87f9a33b91220d687146a6fbe9df", + "object_path": "lib/lean/Lean/Compiler/CSimpAttr.olean", + "object_sha256": "be52286be4d6b74659d7459e6ecf9f82f6ed85a286f3d5f4d1615a390b7915c8", + "object_bytes": 406736, + "imports": [ + "Lean.ScopedEnvExtension", + "Lean.Util.Recognizers", + "Lean.Util.ReplaceExpr" + ] + }, + { + "module": "Lean.Compiler.FFI", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/FFI.lean", + "source_sha256": "ef061855c36a8f83fb614e62cf1e2fd927f3ee828f364b98e897539c402e5e66", + "object_path": "lib/lean/Lean/Compiler/FFI.olean", + "object_sha256": "339870c025a71b1b81e3c452f3dfd05d68aafffd31f396e29e6027dcb4362dec", + "object_bytes": 89000, + "imports": [ + "Init.Data.Array.Basic", + "Init.System.FilePath" + ] + }, + { + "module": "Lean.Compiler.NoncomputableAttr", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/NoncomputableAttr.lean", + "source_sha256": "acf08d52bbde81dba9e252efc1d4e65971c7830d7e7ed118fa98c891e2743276", + "object_path": "lib/lean/Lean/Compiler/NoncomputableAttr.olean", + "object_sha256": "31176740edf28a37dd4d66a23d63f4a62a811706ce1f4f687660115918d016c6", + "object_bytes": 30824, + "imports": [ + "Lean.EnvExtension" + ] + }, + { + "module": "Lean.Compiler.LCNF.AlphaEqv", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/AlphaEqv.lean", + "source_sha256": "5b52634971993c639887fb1d1ed69437408d03515cadf332f2fd8afc82efce06", + "object_path": "lib/lean/Lean/Compiler/LCNF/AlphaEqv.olean", + "object_sha256": "0bf33933af96ece08514c650bdc57aba926fa859a7678195a68b23b24407ea91", + "object_bytes": 523344, + "imports": [ + "Lean.Compiler.LCNF.Basic" + ] + }, + { + "module": "Lean.Compiler.LCNF.BaseTypes", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/BaseTypes.lean", + "source_sha256": "39b6fa5a0f337ccdac48fada884ac55940e51b25599c50d8aecc80a8384e6d09", + "object_path": "lib/lean/Lean/Compiler/LCNF/BaseTypes.olean", + "object_sha256": "9cc58c45a562f58870a546e4edc0aeedf2d060b4ca2681342438feda0aab372c", + "object_bytes": 230896, + "imports": [ + "Lean.Compiler.LCNF.CompilerM", + "Lean.Compiler.LCNF.Types" + ] + }, + { + "module": "Lean.Compiler.LCNF.Util", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/Util.lean", + "source_sha256": "708482ffaeac2d3c09dd9c6ec1745b8ef03756e86937b4bd3a7257a83b24a2c7", + "object_path": "lib/lean/Lean/Compiler/LCNF/Util.olean", + "object_sha256": "74d491b28e99756acb584b96e923d2fc980d0291880057fd8f3266bbbfa11c1a", + "object_bytes": 290976, + "imports": [ + "Init.Data.FloatArray.Basic", + "Lean.CoreM", + "Lean.MonadEnv", + "Lean.Util.Recognizers" + ] + }, + { + "module": "Lean.Compiler.LCNF.MonoTypes", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/MonoTypes.lean", + "source_sha256": "b6bae3995b8761bf8d9e7ddd5d643694abd4235387fa2c33269db04b2593848b", + "object_path": "lib/lean/Lean/Compiler/LCNF/MonoTypes.olean", + "object_sha256": "2333f5c9145ad47a0677cbc5051df8e5242f8f80e9c433d2f8c56861dfb71291", + "object_bytes": 707888, + "imports": [ + "Lean.Meta.InferType", + "Lean.Compiler.LCNF.Util", + "Lean.Compiler.LCNF.BaseTypes", + "Lean.Compiler.LCNF.CompilerM" + ] + }, + { + "module": "Lean.Compiler.LCNF.OtherDecl", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/OtherDecl.lean", + "source_sha256": "4f9177ebf42ec1253974d9d85d536dc3f249d6c4f0c6252f610cdda1da96ead8", + "object_path": "lib/lean/Lean/Compiler/LCNF/OtherDecl.olean", + "object_sha256": "8fcd4dc5cf62c1a995629a892dad3bd39dcae63b480fd2f80ac77193a37f1279", + "object_bytes": 49056, + "imports": [ + "Lean.Compiler.LCNF.BaseTypes", + "Lean.Compiler.LCNF.MonoTypes" + ] + }, + { + "module": "Lean.Compiler.LCNF.InferType", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/InferType.lean", + "source_sha256": "a1c4b6d9807827ff749e765542feda5ad0485b7e52a6e0161fb947c357751da0", + "object_path": "lib/lean/Lean/Compiler/LCNF/InferType.olean", + "object_sha256": "0bc483346e9688f4f064c2530e7b9f8c36a266e6d6f760cec44f4858c1d03a7d", + "object_bytes": 1532000, + "imports": [ + "Lean.Compiler.LCNF.CompilerM", + "Lean.Compiler.LCNF.Types", + "Lean.Compiler.LCNF.PhaseExt", + "Lean.Compiler.LCNF.OtherDecl" + ] + }, + { + "module": "Lean.Compiler.LCNF.Bind", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/Bind.lean", + "source_sha256": "0b34b5d9b35bc3ac7120746b38998af258d70ce0a7e2023454084a98b332390b", + "object_path": "lib/lean/Lean/Compiler/LCNF/Bind.olean", + "object_sha256": "b2bc561ddec25cedd457d2b96c8206ba180cde97e7e7137eccfbc1f98adf6333", + "object_bytes": 348712, + "imports": [ + "Lean.Compiler.LCNF.InferType" + ] + }, + { + "module": "Lean.PrettyPrinter.Delaborator.Options", + "root": "lean", + "source_path": "src/lean/Lean/PrettyPrinter/Delaborator/Options.lean", + "source_sha256": "b9c9c0d2f4717359cec78c7487f79e19e21f9a5346b06747fb6cab58a8048778", + "object_path": "lib/lean/Lean/PrettyPrinter/Delaborator/Options.olean", + "object_sha256": "07e469f0b8fa71156a58f7c0bc16f483b9b9c616f8decd1d8d913129843da161", + "object_bytes": 340288, + "imports": [ + "Lean.Data.Options" + ] + }, + { + "module": "Lean.Compiler.LCNF.Internalize", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/Internalize.lean", + "source_sha256": "c4ed37ef26076b80ad59ddff0ec2eb6438ba67038ac357b0b094fddc98b4450c", + "object_path": "lib/lean/Lean/Compiler/LCNF/Internalize.olean", + "object_sha256": "08d181dfc84688cd5f4cd895e0da75a1d4f7b03113b1490d410f2914968229ad", + "object_bytes": 427328, + "imports": [ + "Lean.Compiler.LCNF.Types", + "Lean.Compiler.LCNF.Bind", + "Lean.Compiler.LCNF.CompilerM" + ] + }, + { + "module": "Lean.Compiler.LCNF.PrettyPrinter", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/PrettyPrinter.lean", + "source_sha256": "90b711bfa5887cf724dbf6ef38c224171c2972f463e932423e05cc965042b470", + "object_path": "lib/lean/Lean/Compiler/LCNF/PrettyPrinter.olean", + "object_sha256": "1e373fa37e5424ad043894e8b0cf7227bff439c6fdc95239c4442d03f8abf9b6", + "object_bytes": 571416, + "imports": [ + "Lean.PrettyPrinter.Delaborator.Options", + "Lean.Compiler.LCNF.CompilerM", + "Lean.Compiler.LCNF.Internalize" + ] + }, + { + "module": "Lean.Compiler.LCNF.CompatibleTypes", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/CompatibleTypes.lean", + "source_sha256": "fcd04d9c8f7dcc95da8378e3417cdbbfd39260fb73ad0e57dc673da32db83afe", + "object_path": "lib/lean/Lean/Compiler/LCNF/CompatibleTypes.olean", + "object_sha256": "b26d5f3c25a76cd0783da2158fcdd62c7b0949bdb6516ec6c6c2fbdaa44afe5a", + "object_bytes": 515072, + "imports": [ + "Lean.Compiler.LCNF.InferType" + ] + }, + { + "module": "Lean.Compiler.LCNF.Check", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/Check.lean", + "source_sha256": "085387ad094b0fd3decad439a58b2ea885168f70c598f52c0bd9ffc6c11d17db", + "object_path": "lib/lean/Lean/Compiler/LCNF/Check.olean", + "object_sha256": "f8af1357c1f53b6ba64180e2535dad721a0b8cb20f4e82bb0d58f4d1491279de", + "object_bytes": 1381408, + "imports": [ + "Lean.Compiler.LCNF.InferType", + "Lean.Compiler.LCNF.PrettyPrinter", + "Lean.Compiler.LCNF.CompatibleTypes" + ] + }, + { + "module": "Lean.Compiler.LCNF.ToExpr", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/ToExpr.lean", + "source_sha256": "58af208d286aee5bfc4fe9bd61da47ca666e282a7ecb41ec98104c4ece7b4fe0", + "object_path": "lib/lean/Lean/Compiler/LCNF/ToExpr.olean", + "object_sha256": "b7a8bdaa9f0948738a1bbccf6ed083eab8e993a6d81b121ba967178711e90522", + "object_bytes": 318200, + "imports": [ + "Lean.Compiler.LCNF.Basic" + ] + }, + { + "module": "Lean.Compiler.LCNF.CSE", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/CSE.lean", + "source_sha256": "14dbd689e32326fb0baa2aea7aac671510760cc1640f2b7d8aa5bcb73318849c", + "object_path": "lib/lean/Lean/Compiler/LCNF/CSE.olean", + "object_sha256": "e88754df2ccc8a698ed96503d205d7a445d644d8b8868fe386b72b20415b070d", + "object_bytes": 560592, + "imports": [ + "Lean.Compiler.LCNF.CompilerM", + "Lean.Compiler.LCNF.ToExpr", + "Lean.Compiler.LCNF.PassManager" + ] + }, + { + "module": "Lean.Compiler.LCNF.DependsOn", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/DependsOn.lean", + "source_sha256": "18e090ccb8b60d35dd204fa900a0276b2ba865e389c0ad463cde5e8879d02ea5", + "object_path": "lib/lean/Lean/Compiler/LCNF/DependsOn.olean", + "object_sha256": "cf36d6f35a4c64f1c41ced8fb32c448d157b82531eb366ac5f395f4891ce2c2b", + "object_bytes": 125808, + "imports": [ + "Lean.Compiler.LCNF.Basic" + ] + }, + { + "module": "Lean.Compiler.LCNF.ElimDead", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/ElimDead.lean", + "source_sha256": "4c08876514d3c802676e3b6ea9d3d542248929dc7ff31f0ebab9d8c781d016cf", + "object_path": "lib/lean/Lean/Compiler/LCNF/ElimDead.olean", + "object_sha256": "614bd624c84fca962fc6709413d9935f4b0d6d603fe7d361de10f93271dcb29b", + "object_bytes": 454624, + "imports": [ + "Lean.Compiler.LCNF.CompilerM" + ] + }, + { + "module": "Lean.Compiler.LCNF.FixedParams", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/FixedParams.lean", + "source_sha256": "370c7fef7acf362d2eb23190a644f69e76a5439f6806003d69cd12f1e5c5936d", + "object_path": "lib/lean/Lean/Compiler/LCNF/FixedParams.olean", + "object_sha256": "3826b0d128de1d18abc777d936d941d3d48f130a9d53ac34450eda4204c707a1", + "object_bytes": 556552, + "imports": [ + "Lean.Compiler.LCNF.Basic", + "Lean.Compiler.LCNF.Types" + ] + }, + { + "module": "Lean.Compiler.LCNF.PullFunDecls", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/PullFunDecls.lean", + "source_sha256": "97e41f69e783249b6c80fd69f4af64be650f36febf5b666be154e54955bc44e5", + "object_path": "lib/lean/Lean/Compiler/LCNF/PullFunDecls.olean", + "object_sha256": "5269cb6ef64188a71e9cd50895e3bc095d7102293a82b6d9e7508397f7475bd3", + "object_bytes": 423776, + "imports": [ + "Lean.Compiler.LCNF.CompilerM", + "Lean.Compiler.LCNF.DependsOn", + "Lean.Compiler.LCNF.PassManager" + ] + }, + { + "module": "Lean.Compiler.LCNF.FVarUtil", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/FVarUtil.lean", + "source_sha256": "98ef4520c058b77818de11afb913de379204961e084025dfa33dec6896ca5b1e", + "object_path": "lib/lean/Lean/Compiler/LCNF/FVarUtil.olean", + "object_sha256": "aec4338b42af38f3800a12b759e34bb6ff8c190018d4af5c3f9fcac80482613c", + "object_bytes": 763064, + "imports": [ + "Lean.Expr", + "Lean.Compiler.LCNF.Basic", + "Lean.Compiler.LCNF.CompilerM" + ] + }, + { + "module": "Lean.Compiler.LCNF.ScopeM", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/ScopeM.lean", + "source_sha256": "6a5216ffc12284953a5e37df119bc847b6e240fbe85e338a622aeff814b628ef", + "object_path": "lib/lean/Lean/Compiler/LCNF/ScopeM.olean", + "object_sha256": "4fec940815386f21b209a8fa58ab432005a140999f59b0cb8225626a44268209", + "object_bytes": 88664, + "imports": [ + "Lean.Compiler.LCNF.CompilerM" + ] + }, + { + "module": "Lean.Compiler.LCNF.JoinPoints", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/JoinPoints.lean", + "source_sha256": "99ab42a3c341e7f7a7b38ecc2f3d7764fc8457aeaf2bae8ee7ddd1ffb1fba545", + "object_path": "lib/lean/Lean/Compiler/LCNF/JoinPoints.olean", + "object_sha256": "6b5af95ae258797bcea82c85610a1ea317f75a40a9a2b928caeb40ecbf767b34", + "object_bytes": 2064520, + "imports": [ + "Lean.Compiler.LCNF.CompilerM", + "Lean.Compiler.LCNF.PassManager", + "Lean.Compiler.LCNF.PullFunDecls", + "Lean.Compiler.LCNF.FVarUtil", + "Lean.Compiler.LCNF.ScopeM", + "Lean.Compiler.LCNF.InferType" + ] + }, + { + "module": "Lean.Util.CollectLevelParams", + "root": "lean", + "source_path": "src/lean/Lean/Util/CollectLevelParams.lean", + "source_sha256": "d987084649222be9cd52c40699a9eeaffdfeefdb3257d9e198386d884c741285", + "object_path": "lib/lean/Lean/Util/CollectLevelParams.olean", + "object_sha256": "aab12ad386d9dafef86a674f55acbf0088d401fbe6fdf811e6668e773018001a", + "object_bytes": 238152, + "imports": [ + "Lean.Expr" + ] + }, + { + "module": "Lean.Compiler.LCNF.Level", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/Level.lean", + "source_sha256": "5eabcf492a19aef7534af90407ae7b4f5872f000b5078c610ab98158d5d94938", + "object_path": "lib/lean/Lean/Compiler/LCNF/Level.olean", + "object_sha256": "bcbf54f2c91e025bc71bb77a518527696f02f4180d063672aa3af872ccf0c1a7", + "object_bytes": 421288, + "imports": [ + "Lean.Util.CollectLevelParams", + "Lean.Compiler.LCNF.Basic" + ] + }, + { + "module": "Lean.Compiler.Options", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/Options.lean", + "source_sha256": "1caa04c065231d9739516f314a65e30fe1c43764267a53b45196ece108889103", + "object_path": "lib/lean/Lean/Compiler/Options.olean", + "object_sha256": "539a82bed523dbeb1bafbd7372b59d702dfeb60b341b3a539d4567b5940ff51d", + "object_bytes": 30944, + "imports": [ + "Lean.Util.Trace", + "Lean.Data.Options" + ] + }, + { + "module": "Lean.Compiler.LCNF.PullLetDecls", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/PullLetDecls.lean", + "source_sha256": "20277de4d3025b8190a053b3346369486c778fdb13950c814cc6e8f5875955a1", + "object_path": "lib/lean/Lean/Compiler/LCNF/PullLetDecls.olean", + "object_sha256": "cc2e9c3b9666fbaf25afc8baa1034fb3e7e8b082bc894155ad17c5c344ad11c2", + "object_bytes": 419784, + "imports": [ + "Lean.Compiler.LCNF.CompilerM", + "Lean.Compiler.LCNF.DependsOn", + "Lean.Compiler.LCNF.Types", + "Lean.Compiler.LCNF.PassManager" + ] + }, + { + "module": "Lean.Compiler.LCNF.ReduceJpArity", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/ReduceJpArity.lean", + "source_sha256": "84a1a63e025feb1b0f301156b7ca9ecf98ce5513648117c218d9d0831cf79c65", + "object_path": "lib/lean/Lean/Compiler/LCNF/ReduceJpArity.olean", + "object_sha256": "9bee676368f4f89f2fddc976feedae60c413639cc05508eb4b03135a87667641", + "object_bytes": 301112, + "imports": [ + "Lean.Compiler.LCNF.CompilerM", + "Lean.Compiler.LCNF.InferType", + "Lean.Compiler.LCNF.PassManager" + ] + }, + { + "module": "Lean.Compiler.LCNF.Renaming", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/Renaming.lean", + "source_sha256": "83e870281d68d6f76a4fdc93ea1c1be8baea42032b42c2c9bc07584814b575a9", + "object_path": "lib/lean/Lean/Compiler/LCNF/Renaming.olean", + "object_sha256": "5c7906b4c6eb75066a0dd6ca335a932f7698a298b0812c10b68e3dc2c0ddbd2d", + "object_bytes": 222792, + "imports": [ + "Lean.Compiler.LCNF.CompilerM" + ] + }, + { + "module": "Lean.Compiler.LCNF.Simp.Basic", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/Simp/Basic.lean", + "source_sha256": "0e14585dbe253987013c46f8fe10247a99a467efe5525b822b03521d493cb3aa", + "object_path": "lib/lean/Lean/Compiler/LCNF/Simp/Basic.olean", + "object_sha256": "f36adc3616da66c344e398fb6a6b2f8e9d25ff341d155485689ea8325a97121d", + "object_bytes": 64600, + "imports": [ + "Lean.Meta.Instances", + "Lean.Compiler.InlineAttrs", + "Lean.Compiler.Specialize", + "Lean.Compiler.LCNF.CompilerM" + ] + }, + { + "module": "Lean.Compiler.LCNF.Simp.FunDeclInfo", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/Simp/FunDeclInfo.lean", + "source_sha256": "cfa2c4b9b1d63024876df6f419c4c6a772c32a1255418d1fb28e1a8711d5fde4", + "object_path": "lib/lean/Lean/Compiler/LCNF/Simp/FunDeclInfo.olean", + "object_sha256": "36b2a27bb29167916dd8810f03876a639fc7f0135d0c10a090ad480ba0f92893", + "object_bytes": 445528, + "imports": [ + "Lean.Compiler.LCNF.Simp.Basic" + ] + }, + { + "module": "Lean.Compiler.LCNF.Simp.DiscrM", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/Simp/DiscrM.lean", + "source_sha256": "92c1a83807502c42e6084d6706e7910d2f810dcc3611ea57e104ce0d4819f528", + "object_path": "lib/lean/Lean/Compiler/LCNF/Simp/DiscrM.olean", + "object_sha256": "450a1ae0cbe6fe7e4479aa4e6ce9a129fd2d572479602dc705ea0a4e5a18d17f", + "object_bytes": 445568, + "imports": [ + "Lean.Compiler.LCNF.CompilerM", + "Lean.Compiler.LCNF.Types", + "Lean.Compiler.LCNF.InferType", + "Lean.Compiler.LCNF.Simp.Basic" + ] + }, + { + "module": "Lean.Compiler.LCNF.Simp.JpCases", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/Simp/JpCases.lean", + "source_sha256": "7d8a3400eb9f64abb3846706c27d7011d426c142b29d16beea6ccaee5aae19dc", + "object_path": "lib/lean/Lean/Compiler/LCNF/Simp/JpCases.olean", + "object_sha256": "5c1907ae46cee3337b0e9bae4a7955f55ec78aaa79cd307832b3d31b94e1c078", + "object_bytes": 911984, + "imports": [ + "Lean.Compiler.LCNF.DependsOn", + "Lean.Compiler.LCNF.InferType", + "Lean.Compiler.LCNF.Internalize", + "Lean.Compiler.LCNF.Simp.Basic", + "Lean.Compiler.LCNF.Simp.DiscrM" + ] + }, + { + "module": "Lean.Compiler.LCNF.Simp.Config", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/Simp/Config.lean", + "source_sha256": "04e394fb9dc19f121df083e0682eb79d1f3a5974c9ce857d0c376256799bfd74", + "object_path": "lib/lean/Lean/Compiler/LCNF/Simp/Config.olean", + "object_sha256": "7af49241d99d6ba167feaf3818ffe6136278de1db118573ac61d2061009ddace", + "object_bytes": 62624, + "imports": [ + "Init.Core" + ] + }, + { + "module": "Lean.Compiler.LCNF.Simp.SimpM", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/Simp/SimpM.lean", + "source_sha256": "7ae5648cbf592084b51ee22bda65dd132fe6cb78941518b58d6a121dd1b91734", + "object_path": "lib/lean/Lean/Compiler/LCNF/Simp/SimpM.olean", + "object_sha256": "f4ef6304a1dd9f74ce4640f1b4f29c25098209983fde7684ff1e4ffad9d56a8e", + "object_bytes": 765776, + "imports": [ + "Lean.Compiler.ImplementedByAttr", + "Lean.Compiler.LCNF.Renaming", + "Lean.Compiler.LCNF.ElimDead", + "Lean.Compiler.LCNF.AlphaEqv", + "Lean.Compiler.LCNF.PrettyPrinter", + "Lean.Compiler.LCNF.Bind", + "Lean.Compiler.LCNF.Internalize", + "Lean.Compiler.LCNF.Simp.JpCases", + "Lean.Compiler.LCNF.Simp.DiscrM", + "Lean.Compiler.LCNF.Simp.FunDeclInfo", + "Lean.Compiler.LCNF.Simp.Config" + ] + }, + { + "module": "Lean.Compiler.LCNF.Simp.InlineCandidate", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/Simp/InlineCandidate.lean", + "source_sha256": "873bece514c846a0ee65ccb7b4562498803cfde8484db232e1c327827a805146", + "object_path": "lib/lean/Lean/Compiler/LCNF/Simp/InlineCandidate.olean", + "object_sha256": "11478b78c544ec38657d3c3d5d09eda5047123e8ae7434f85360c6a3cadcc12d", + "object_bytes": 351200, + "imports": [ + "Lean.Compiler.LCNF.Simp.SimpM" + ] + }, + { + "module": "Lean.Compiler.LCNF.Simp.InlineProj", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/Simp/InlineProj.lean", + "source_sha256": "1152dd4b82c72754c00fa3cc225b28d158d6a805b14aafb6f9c9d380639ea336", + "object_path": "lib/lean/Lean/Compiler/LCNF/Simp/InlineProj.olean", + "object_sha256": "5bac2970939c83bf54a235002f1e99392a71847e1a5f579456c6d243b1af804e", + "object_bytes": 281264, + "imports": [ + "Lean.Compiler.LCNF.Simp.SimpM" + ] + }, + { + "module": "Lean.Compiler.LCNF.Simp.Used", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/Simp/Used.lean", + "source_sha256": "8f08ac6814448c95f8afb118871bb5512de8c5aa3f6423e9019cf22cedd32d41", + "object_path": "lib/lean/Lean/Compiler/LCNF/Simp/Used.olean", + "object_sha256": "e89cd0c89bf2b6573b855b606b681ea68e35a65dc1e6a730fd766a39b038eb4c", + "object_bytes": 295040, + "imports": [ + "Lean.Compiler.LCNF.Simp.SimpM" + ] + }, + { + "module": "Lean.Compiler.LCNF.Simp.DefaultAlt", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/Simp/DefaultAlt.lean", + "source_sha256": "93db68be8f70b2aff260e925cd9d5f678634c84ed31640c182eae159b100cc89", + "object_path": "lib/lean/Lean/Compiler/LCNF/Simp/DefaultAlt.olean", + "object_sha256": "2f17c0896167103557b4e394f117b901556e3f9f4e94b0554e1d3e6b4ef84d6c", + "object_bytes": 182400, + "imports": [ + "Lean.Compiler.LCNF.Simp.SimpM" + ] + }, + { + "module": "Lean.Compiler.LCNF.Simp.SimpValue", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/Simp/SimpValue.lean", + "source_sha256": "7d33a8016e7b6a2bdc848a347e731fe1e40b95a1e3af9ccb29259a52154dde78", + "object_path": "lib/lean/Lean/Compiler/LCNF/Simp/SimpValue.olean", + "object_sha256": "9b5546d7e52b019ee73245a276cf8075d16754166aa17c107c01ce83ae96e90e", + "object_bytes": 184960, + "imports": [ + "Lean.Compiler.LCNF.Simp.SimpM" + ] + }, + { + "module": "Lean.Compiler.LCNF.Simp.ConstantFold", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/Simp/ConstantFold.lean", + "source_sha256": "2aaa1ce5599ae3d0682dc10f9c84b10ef72791b17b29600e45bcdd5de0618aba", + "object_path": "lib/lean/Lean/Compiler/LCNF/Simp/ConstantFold.olean", + "object_sha256": "188886636b514e6f024678dffc821737948f49646699472031476df7989a4b2d", + "object_bytes": 1628112, + "imports": [ + "Init.Data.UInt.Log2", + "Lean.Compiler.LCNF.CompilerM", + "Lean.Compiler.LCNF.InferType", + "Lean.Compiler.LCNF.PassManager" + ] + }, + { + "module": "Lean.Compiler.LCNF.Simp.Main", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/Simp/Main.lean", + "source_sha256": "c0fc5aa8a6678c79afeca97014364ac490f4b97d348e53c24ead72f9034a3a0a", + "object_path": "lib/lean/Lean/Compiler/LCNF/Simp/Main.olean", + "object_sha256": "b2e6d8834204193d5e6177550ed3c38d20f409a0b635891bb5a6ec22e87d4c64", + "object_bytes": 1657328, + "imports": [ + "Lean.Compiler.ImplementedByAttr", + "Lean.Compiler.LCNF.ElimDead", + "Lean.Compiler.LCNF.AlphaEqv", + "Lean.Compiler.LCNF.PrettyPrinter", + "Lean.Compiler.LCNF.Bind", + "Lean.Compiler.LCNF.Simp.FunDeclInfo", + "Lean.Compiler.LCNF.Simp.InlineCandidate", + "Lean.Compiler.LCNF.Simp.InlineProj", + "Lean.Compiler.LCNF.Simp.Used", + "Lean.Compiler.LCNF.Simp.DefaultAlt", + "Lean.Compiler.LCNF.Simp.SimpValue", + "Lean.Compiler.LCNF.Simp.ConstantFold" + ] + }, + { + "module": "Lean.Compiler.LCNF.Simp", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/Simp.lean", + "source_sha256": "15199ae35e7483cbbccd272f1ad72d4272be49b3249c4ea90c6797be961abda8", + "object_path": "lib/lean/Lean/Compiler/LCNF/Simp.olean", + "object_sha256": "e95911e755db7a25a810543a63cd0c37ba1e5163758b2b146b65508dfd01db92", + "object_bytes": 280856, + "imports": [ + "Lean.Compiler.LCNF.ReduceJpArity", + "Lean.Compiler.LCNF.Renaming", + "Lean.Compiler.LCNF.Simp.Basic", + "Lean.Compiler.LCNF.Simp.FunDeclInfo", + "Lean.Compiler.LCNF.Simp.JpCases", + "Lean.Compiler.LCNF.Simp.Config", + "Lean.Compiler.LCNF.Simp.InlineCandidate", + "Lean.Compiler.LCNF.Simp.SimpM", + "Lean.Compiler.LCNF.Simp.Main", + "Lean.Compiler.LCNF.Simp.InlineProj", + "Lean.Compiler.LCNF.Simp.DefaultAlt", + "Lean.Compiler.LCNF.Simp.SimpValue", + "Lean.Compiler.LCNF.Simp.Used" + ] + }, + { + "module": "Lean.Compiler.LCNF.SpecInfo", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/SpecInfo.lean", + "source_sha256": "eb8a7cfe4e4e44571892a959218a432174e746632eacd78c7765d1c8c1f5267d", + "object_path": "lib/lean/Lean/Compiler/LCNF/SpecInfo.olean", + "object_sha256": "69971b8aeffd452b22fc2f5156709e459d2670b17e3538d5a957f14b855d86c4", + "object_bytes": 735072, + "imports": [ + "Lean.Compiler.Specialize", + "Lean.Compiler.LCNF.FixedParams", + "Lean.Compiler.LCNF.InferType" + ] + }, + { + "module": "Lean.Compiler.LCNF.MonadScope", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/MonadScope.lean", + "source_sha256": "e8617c8581580f7fee738fcecc2c969a1e317802231ce0337da78141193d8ce9", + "object_path": "lib/lean/Lean/Compiler/LCNF/MonadScope.olean", + "object_sha256": "4af6d9fa17c32fc90647e6709b0ca5d6f33ce728a29a0207996700be54d6bf37", + "object_bytes": 106016, + "imports": [ + "Lean.Compiler.LCNF.Basic" + ] + }, + { + "module": "Lean.Util.ForEachExprWhere", + "root": "lean", + "source_path": "src/lean/Lean/Util/ForEachExprWhere.lean", + "source_sha256": "b8d21d870c2eeb10cfc394bd15f653ff8e5a3def9a006f32126e561f688cca6a", + "object_path": "lib/lean/Lean/Util/ForEachExprWhere.olean", + "object_sha256": "3023ed453ce840ac3200d19dd37c7345b57709d65878d75faaabc96b7de3f33c", + "object_bytes": 283288, + "imports": [ + "Lean.Expr", + "Lean.Util.MonadCache" + ] + }, + { + "module": "Lean.Compiler.LCNF.Closure", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/Closure.lean", + "source_sha256": "b27728cbcd99d04b18a3e72d727052d3a16afb9644f785a39c4b58846105a943", + "object_path": "lib/lean/Lean/Compiler/LCNF/Closure.olean", + "object_sha256": "ff7b1b0c79481a54a62c94baf4de9f0f71a85bfda6a8036500472306ac5c0db7", + "object_bytes": 597808, + "imports": [ + "Lean.Util.ForEachExprWhere", + "Lean.Compiler.LCNF.CompilerM" + ] + }, + { + "module": "Lean.Compiler.LCNF.Specialize", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/Specialize.lean", + "source_sha256": "cc0e6f89e3a24d36bd6682215028abd841c34b8af6b5d31e3aa9cfa303bf61a7", + "object_path": "lib/lean/Lean/Compiler/LCNF/Specialize.olean", + "object_sha256": "c80e52a03d86537d112919f26076e46bfef4078478e02f58ee6e8cca3e61c6c6", + "object_bytes": 1416464, + "imports": [ + "Lean.Compiler.Specialize", + "Lean.Compiler.LCNF.Simp", + "Lean.Compiler.LCNF.SpecInfo", + "Lean.Compiler.LCNF.PrettyPrinter", + "Lean.Compiler.LCNF.ToExpr", + "Lean.Compiler.LCNF.Level", + "Lean.Compiler.LCNF.PhaseExt", + "Lean.Compiler.LCNF.MonadScope", + "Lean.Compiler.LCNF.Closure", + "Lean.Compiler.LCNF.FVarUtil" + ] + }, + { + "module": "Lean.Compiler.LCNF.ToMono", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/ToMono.lean", + "source_sha256": "a11b4054d4cb3112fb6650d72af4cbea4345864195ac92fd95c28a2f150a6876", + "object_path": "lib/lean/Lean/Compiler/LCNF/ToMono.olean", + "object_sha256": "07046236545899be6cf343b989e9c4e98d39b51e32b2d44c40f135ff937190d6", + "object_bytes": 1156192, + "imports": [ + "Lean.Compiler.ExternAttr", + "Lean.Compiler.LCNF.MonoTypes", + "Lean.Compiler.LCNF.InferType", + "Lean.Compiler.NoncomputableAttr" + ] + }, + { + "module": "Lean.Compiler.LCNF.DeclHash", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/DeclHash.lean", + "source_sha256": "7e2e2b59437e571dff1addecbb0021f9a6fae6bfcb2396ba8c23987031ad83ed", + "object_path": "lib/lean/Lean/Compiler/LCNF/DeclHash.olean", + "object_sha256": "b04929547c0f229f7e49ed6c6f87adc80845747fc5c051e66886b182466e0166", + "object_bytes": 149872, + "imports": [ + "Lean.Compiler.LCNF.Basic" + ] + }, + { + "module": "Lean.Compiler.LCNF.AuxDeclCache", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/AuxDeclCache.lean", + "source_sha256": "39428082cb17d44fc3f752be3adff23d7f67b490ad190dee51e88320173f5606", + "object_path": "lib/lean/Lean/Compiler/LCNF/AuxDeclCache.olean", + "object_sha256": "c6e79b898ceb8fee3a3689769ce4140e49e546ceff258cfc73ab50eb00c61e4e", + "object_bytes": 204816, + "imports": [ + "Lean.Compiler.LCNF.CompilerM", + "Lean.Compiler.LCNF.DeclHash", + "Lean.Compiler.LCNF.Internalize" + ] + }, + { + "module": "Lean.Compiler.LCNF.LambdaLifting", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/LambdaLifting.lean", + "source_sha256": "809c0d240ab4a3e8498fe4f892a94cd62cec6260e9202caa3bc733095342008e", + "object_path": "lib/lean/Lean/Compiler/LCNF/LambdaLifting.olean", + "object_sha256": "db74fa128a0d001905a1ca9e799c93c386f80c5fae8fcee0f1b5c77b9d35c74b", + "object_bytes": 532288, + "imports": [ + "Lean.Meta.Instances", + "Lean.Compiler.InlineAttrs", + "Lean.Compiler.LCNF.Closure", + "Lean.Compiler.LCNF.Types", + "Lean.Compiler.LCNF.MonadScope", + "Lean.Compiler.LCNF.Internalize", + "Lean.Compiler.LCNF.Level", + "Lean.Compiler.LCNF.AuxDeclCache" + ] + }, + { + "module": "Lean.Compiler.LCNF.FloatLetIn", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/FloatLetIn.lean", + "source_sha256": "734623956353ff17888f1c8d52343ca1a6f67783a994364bd6b8a6c1386dd88d", + "object_path": "lib/lean/Lean/Compiler/LCNF/FloatLetIn.olean", + "object_sha256": "480682134d9c26327459038b0ec72e5a6f14997792def6640c209ea2e1e8780c", + "object_bytes": 1292896, + "imports": [ + "Lean.Compiler.LCNF.CompilerM", + "Lean.Compiler.LCNF.FVarUtil", + "Lean.Compiler.LCNF.PassManager", + "Lean.Compiler.LCNF.Types" + ] + }, + { + "module": "Lean.Compiler.LCNF.ReduceArity", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/ReduceArity.lean", + "source_sha256": "6e134e3a963387e7fb110c53e2fddf0cc03a30296d8f0f3886063297bb4ddc95", + "object_path": "lib/lean/Lean/Compiler/LCNF/ReduceArity.olean", + "object_sha256": "991535170aa9f04921a8f53c1d074b1f4e37e7be2496caa7641dbc6222e91333", + "object_bytes": 736296, + "imports": [ + "Lean.Compiler.LCNF.CompilerM", + "Lean.Compiler.LCNF.PhaseExt", + "Lean.Compiler.LCNF.InferType", + "Lean.Compiler.LCNF.Internalize" + ] + }, + { + "module": "Lean.Compiler.LCNF.ElimDeadBranches", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/ElimDeadBranches.lean", + "source_sha256": "a7a4486b0249c1a448a9f1b97fa573026ce515d73f426671b8e40e9b7743ad59", + "object_path": "lib/lean/Lean/Compiler/LCNF/ElimDeadBranches.olean", + "object_sha256": "99a762117715000b20fdcc3a0cfc7577f609757b5d5ab56ca6e19289fdae79fe", + "object_bytes": 1998608, + "imports": [ + "Lean.Compiler.LCNF.CompilerM", + "Lean.Compiler.LCNF.PassManager", + "Lean.Compiler.LCNF.PhaseExt", + "Lean.Compiler.LCNF.InferType" + ] + }, + { + "module": "Lean.Compiler.LCNF.StructProjCases", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/StructProjCases.lean", + "source_sha256": "67db85c84379b599a04353f7fa666cb0bb3c08cf502f418206813f0a462e0619", + "object_path": "lib/lean/Lean/Compiler/LCNF/StructProjCases.olean", + "object_sha256": "b147bbbd4e66e5157f5866469e1ae6bc076fe3b8d33cb1253ac96961b0b2b6eb", + "object_bytes": 817408, + "imports": [ + "Lean.Compiler.LCNF.Basic", + "Lean.Compiler.LCNF.InferType", + "Lean.Compiler.LCNF.MonoTypes", + "Lean.Compiler.LCNF.PassManager", + "Lean.Compiler.LCNF.PrettyPrinter" + ] + }, + { + "module": "Lean.Compiler.LCNF.ExtractClosed", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/ExtractClosed.lean", + "source_sha256": "b0c9f3a8603a94add33bc75e328c0a700f4bfb02063cc0956c2c2b3bbae382a4", + "object_path": "lib/lean/Lean/Compiler/LCNF/ExtractClosed.olean", + "object_sha256": "175622081d0a5bec61787626ad4e97b524da1df7aa1e60e8d895ebbf097ace28", + "object_bytes": 501512, + "imports": [ + "Lean.Compiler.ClosedTermCache", + "Lean.Compiler.NeverExtractAttr", + "Lean.Compiler.LCNF.Basic", + "Lean.Compiler.LCNF.InferType", + "Lean.Compiler.LCNF.Internalize", + "Lean.Compiler.LCNF.MonoTypes", + "Lean.Compiler.LCNF.PassManager", + "Lean.Compiler.LCNF.ToExpr" + ] + }, + { + "module": "Lean.Compiler.LCNF.Passes", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/Passes.lean", + "source_sha256": "e17fd41ce62f9bd9f40ecfa1f84dbe3e38873ebe817d1e4b2aeb23dda38f8f9d", + "object_path": "lib/lean/Lean/Compiler/LCNF/Passes.olean", + "object_sha256": "42a0130d1e14b04bb5cc5819f080e8909636bf47b9cddaf6290f3bc9c5959039", + "object_bytes": 376032, + "imports": [ + "Lean.Compiler.LCNF.PassManager", + "Lean.Compiler.LCNF.PullLetDecls", + "Lean.Compiler.LCNF.CSE", + "Lean.Compiler.LCNF.Simp", + "Lean.Compiler.LCNF.PullFunDecls", + "Lean.Compiler.LCNF.ReduceJpArity", + "Lean.Compiler.LCNF.JoinPoints", + "Lean.Compiler.LCNF.Specialize", + "Lean.Compiler.LCNF.PhaseExt", + "Lean.Compiler.LCNF.ToMono", + "Lean.Compiler.LCNF.LambdaLifting", + "Lean.Compiler.LCNF.FloatLetIn", + "Lean.Compiler.LCNF.ReduceArity", + "Lean.Compiler.LCNF.ElimDeadBranches", + "Lean.Compiler.LCNF.StructProjCases", + "Lean.Compiler.LCNF.ExtractClosed" + ] + }, + { + "module": "Lean.Compiler.LCNF.ToLCNF", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/ToLCNF.lean", + "source_sha256": "0e2737b19fa3488fee1d2e99432c0efb12852157a94390bd460136607a720e6a", + "object_path": "lib/lean/Lean/Compiler/LCNF/ToLCNF.olean", + "object_sha256": "2a085bb2dfde8291d2164e3565ab19258a2250dc8c9d10456dfbda744a77d080", + "object_bytes": 2632248, + "imports": [ + "Lean.ProjFns", + "Lean.Meta.CtorRecognizer", + "Lean.Compiler.BorrowedAnnotation", + "Lean.Compiler.CSimpAttr", + "Lean.Compiler.ImplementedByAttr", + "Lean.Compiler.LCNF.Types", + "Lean.Compiler.LCNF.Bind", + "Lean.Compiler.LCNF.InferType", + "Lean.Compiler.LCNF.Util" + ] + }, + { + "module": "Lean.Compiler.LCNF.ToDecl", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/ToDecl.lean", + "source_sha256": "a97d434fdf5f7374e670b8fbc912ac268d8550a4fd2ff74cb016cff242a6f14e", + "object_path": "lib/lean/Lean/Compiler/LCNF/ToDecl.olean", + "object_sha256": "70d5b6dd57eae7222b41c5a1776215b6f35a07b46ae7a8465e408b649d1358d3", + "object_bytes": 601936, + "imports": [ + "Lean.Meta.Transform", + "Lean.Meta.Match.MatcherInfo", + "Lean.Compiler.ExternAttr", + "Lean.Compiler.InitAttr", + "Lean.Compiler.ImplementedByAttr", + "Lean.Compiler.LCNF.ToLCNF" + ] + }, + { + "module": "Lean.Compiler.LCNF.Main", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/Main.lean", + "source_sha256": "7034dc1c69563af7ea2dfbd67430ffd2f5aba1a001c0c0f7a3a5c63f70ba16e2", + "object_path": "lib/lean/Lean/Compiler/LCNF/Main.olean", + "object_sha256": "e69b3dac39864f72285472cea488eccb03cad4e6cb2984bbdba08b9c020b2555", + "object_bytes": 765352, + "imports": [ + "Lean.Compiler.Options", + "Lean.Compiler.ExternAttr", + "Lean.Compiler.IR", + "Lean.Compiler.IR.Basic", + "Lean.Compiler.IR.Checker", + "Lean.Compiler.IR.ToIR", + "Lean.Compiler.LCNF.PassManager", + "Lean.Compiler.LCNF.Passes", + "Lean.Compiler.LCNF.PrettyPrinter", + "Lean.Compiler.LCNF.ToDecl", + "Lean.Compiler.LCNF.Check", + "Lean.Compiler.LCNF.PullLetDecls", + "Lean.Compiler.LCNF.PhaseExt", + "Lean.Compiler.LCNF.CSE" + ] + }, + { + "module": "Lean.Compiler.LCNF.Testing", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/Testing.lean", + "source_sha256": "7f7bcd72bb44b3302a0e0ce8ba819a6289225dac4458beb58271e513eb44bc07", + "object_path": "lib/lean/Lean/Compiler/LCNF/Testing.olean", + "object_sha256": "8e800bbfcbe5b825ee42ef8816c634041be4a0d72bdbe018117ac73347f5c40e", + "object_bytes": 620736, + "imports": [ + "Lean.Compiler.LCNF.PassManager", + "Lean.Compiler.LCNF.PrettyPrinter" + ] + }, + { + "module": "Lean.Compiler.LCNF.Probing", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF/Probing.lean", + "source_sha256": "f024d4b96b9fdc038ad1152286551a549174965339a6fe75994cca26405f5801", + "object_path": "lib/lean/Lean/Compiler/LCNF/Probing.olean", + "object_sha256": "b8509e3b0aedd4b02bd08d4dcec036ad64bd3c8000e67ff9550d4d165b9bf026", + "object_bytes": 868536, + "imports": [ + "Lean.Compiler.LCNF.CompilerM", + "Lean.Compiler.LCNF.PassManager", + "Lean.Compiler.LCNF.PhaseExt" + ] + }, + { + "module": "Lean.Compiler.LCNF", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/LCNF.lean", + "source_sha256": "332ce85f1b3724c84f004e5da4ed906b7b54d86a362fd9b5e9819ef3b301d8fc", + "object_path": "lib/lean/Lean/Compiler/LCNF.olean", + "object_sha256": "ddf4bce5fd7a57e7922b0d07e1146bda2fe6d8ee11b982105d21d49ad69e9404", + "object_bytes": 21624, + "imports": [ + "Lean.Compiler.LCNF.AlphaEqv", + "Lean.Compiler.LCNF.Basic", + "Lean.Compiler.LCNF.Bind", + "Lean.Compiler.LCNF.Check", + "Lean.Compiler.LCNF.CompilerM", + "Lean.Compiler.LCNF.CSE", + "Lean.Compiler.LCNF.DependsOn", + "Lean.Compiler.LCNF.ElimDead", + "Lean.Compiler.LCNF.FixedParams", + "Lean.Compiler.LCNF.InferType", + "Lean.Compiler.LCNF.JoinPoints", + "Lean.Compiler.LCNF.LCtx", + "Lean.Compiler.LCNF.Level", + "Lean.Compiler.LCNF.Main", + "Lean.Compiler.LCNF.Passes", + "Lean.Compiler.LCNF.PassManager", + "Lean.Compiler.LCNF.PhaseExt", + "Lean.Compiler.LCNF.PrettyPrinter", + "Lean.Compiler.LCNF.PullFunDecls", + "Lean.Compiler.LCNF.PullLetDecls", + "Lean.Compiler.LCNF.ReduceJpArity", + "Lean.Compiler.LCNF.Simp", + "Lean.Compiler.LCNF.Specialize", + "Lean.Compiler.LCNF.SpecInfo", + "Lean.Compiler.LCNF.Testing", + "Lean.Compiler.LCNF.ToDecl", + "Lean.Compiler.LCNF.ToExpr", + "Lean.Compiler.LCNF.ToLCNF", + "Lean.Compiler.LCNF.Types", + "Lean.Compiler.LCNF.Util", + "Lean.Compiler.LCNF.ConfigOptions", + "Lean.Compiler.LCNF.MonoTypes", + "Lean.Compiler.LCNF.ToMono", + "Lean.Compiler.LCNF.MonadScope", + "Lean.Compiler.LCNF.Closure", + "Lean.Compiler.LCNF.LambdaLifting", + "Lean.Compiler.LCNF.ReduceArity", + "Lean.Compiler.LCNF.Probing" + ] + }, + { + "module": "Lean.Compiler.Main", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/Main.lean", + "source_sha256": "ef863e5038565cfaed533f0eb07f4fc7b494932e4ca08c3c4244bb6e5dcdaa2f", + "object_path": "lib/lean/Lean/Compiler/Main.olean", + "object_sha256": "d76ebedd1b51d2dabeb23d25a5a981d4476e8af49be37d07be6c3935b0003c65", + "object_bytes": 74944, + "imports": [ + "Lean.Compiler.LCNF" + ] + }, + { + "module": "Lean.Compiler.AtMostOnce", + "root": "lean", + "source_path": "src/lean/Lean/Compiler/AtMostOnce.lean", + "source_sha256": "9cb097d1fb53b0cfea6471161dfd9619564b433badf8e20169c1296410a62bd5", + "object_path": "lib/lean/Lean/Compiler/AtMostOnce.olean", + "object_sha256": "caf6bcc8570c8961f91c6bc71737e4699c20cca33b426e85b8e579ce27e9c093", + "object_bytes": 128912, + "imports": [ + "Lean.Environment" + ] + }, + { + "module": "Lean.Compiler", + "root": "lean", + "source_path": "src/lean/Lean/Compiler.lean", + "source_sha256": "6a47ff3813d47e402bc0daee9d577fd78149d326d965e2771859da57a88f6dd0", + "object_path": "lib/lean/Lean/Compiler.olean", + "object_sha256": "a9a8c20894f28f17b34361f273684cfa8c0d5f4b7037f76822fe1b19dfc3cb1d", + "object_bytes": 19184, + "imports": [ + "Lean.Compiler.InlineAttrs", + "Lean.Compiler.Specialize", + "Lean.Compiler.ConstFolding", + "Lean.Compiler.ClosedTermCache", + "Lean.Compiler.ExternAttr", + "Lean.Compiler.ImplementedByAttr", + "Lean.Compiler.NeverExtractAttr", + "Lean.Compiler.IR", + "Lean.Compiler.CSimpAttr", + "Lean.Compiler.FFI", + "Lean.Compiler.NoncomputableAttr", + "Lean.Compiler.Main", + "Lean.Compiler.AtMostOnce", + "Lean.Compiler.Old" + ] + }, + { + "module": "Lean.Parser.Basic", + "root": "lean", + "source_path": "src/lean/Lean/Parser/Basic.lean", + "source_sha256": "ef312c068d685d2681fbcc7397e29ac71d53d1ffaea6e5555c31cf4a878882ed", + "object_path": "lib/lean/Lean/Parser/Basic.olean", + "object_sha256": "3ffae3a7d79550de038552e316eabeacf4726be79eff66d21e7264d7e674ab64", + "object_bytes": 2169696, + "imports": [ + "Lean.Parser.Types" + ] + }, + { + "module": "Lean.BuiltinDocAttr", + "root": "lean", + "source_path": "src/lean/Lean/BuiltinDocAttr.lean", + "source_sha256": "d2afa10156f84df091664256627652cbc3ab79c1a073c002cb1beef92553b696", + "object_path": "lib/lean/Lean/BuiltinDocAttr.olean", + "object_sha256": "f8172b339e9ff2fc8e5b518c067e0910ea8b8524e3d9e218ac85df63d33fd6ed", + "object_bytes": 165640, + "imports": [ + "Lean.Compiler.InitAttr", + "Lean.DocString.Extension" + ] + }, + { + "module": "Lean.Parser.Extension", + "root": "lean", + "source_path": "src/lean/Lean/Parser/Extension.lean", + "source_sha256": "89d06d19910b1d6b31805f8cf984264a1746219d0e6c03594c4b035321a5f200", + "object_path": "lib/lean/Lean/Parser/Extension.olean", + "object_sha256": "caa3522519afa1fe04bf7dcb5c13201269930c706d9e2c80a366b50055e33abe", + "object_bytes": 1931784, + "imports": [ + "Lean.Parser.Basic", + "Lean.ScopedEnvExtension", + "Lean.BuiltinDocAttr" + ] + }, + { + "module": "Lean.Parser.StrInterpolation", + "root": "lean", + "source_path": "src/lean/Lean/Parser/StrInterpolation.lean", + "source_sha256": "5a6dea041a92a20e7255fdc2a6aadf5ee2e264a1a1790158966efdbbb2dfde65", + "object_path": "lib/lean/Lean/Parser/StrInterpolation.olean", + "object_sha256": "b061fe0000f068dc6e6df29c63aa3c92ec765411c427afef6c55a610a1955c68", + "object_bytes": 87816, + "imports": [ + "Lean.Parser.Basic" + ] + }, + { + "module": "Lean.ParserCompiler.Attribute", + "root": "lean", + "source_path": "src/lean/Lean/ParserCompiler/Attribute.lean", + "source_sha256": "22f975bb6bdd15fb141cae8f7340cc4b73a165e3745be28ab4d29add741cb73b", + "object_path": "lib/lean/Lean/ParserCompiler/Attribute.olean", + "object_sha256": "a82151807b4e31987604df256bebf625f527ec792ae05565044fb45dece87da0", + "object_bytes": 217416, + "imports": [ + "Lean.Attributes", + "Lean.Compiler.InitAttr", + "Lean.ToExpr" + ] + }, + { + "module": "Lean.KeyedDeclsAttribute", + "root": "lean", + "source_path": "src/lean/Lean/KeyedDeclsAttribute.lean", + "source_sha256": "5930e8b404c6deacd4d42adf71ed9b5582906f3d56b27b560ed98c8bdc67fb2f", + "object_path": "lib/lean/Lean/KeyedDeclsAttribute.olean", + "object_sha256": "bf79ecec57c7342d2730a6bd12ec7ba24e039d6e12612511720a8639f53bf9f1", + "object_bytes": 840456, + "imports": [ + "Lean.Compiler.InitAttr", + "Lean.ScopedEnvExtension", + "Lean.Compiler.IR.CompilerM" + ] + }, + { + "module": "Lean.PrettyPrinter.Basic", + "root": "lean", + "source_path": "src/lean/Lean/PrettyPrinter/Basic.lean", + "source_sha256": "9e761308193f9a0c8d8058effaa678782484254518500af8aeb6a9088de6553c", + "object_path": "lib/lean/Lean/PrettyPrinter/Basic.olean", + "object_sha256": "3977a0ca3b6ab74a767b4c61ff8d3f651e212705a8c9ca1805a10f8a2cf7d6c0", + "object_bytes": 98000, + "imports": [ + "Lean.KeyedDeclsAttribute" + ] + }, + { + "module": "Lean.PrettyPrinter.Parenthesizer", + "root": "lean", + "source_path": "src/lean/Lean/PrettyPrinter/Parenthesizer.lean", + "source_sha256": "40d9669d352c2417c51f203de33a84bed043088fbac4ed18b95e9482ffaed917", + "object_path": "lib/lean/Lean/PrettyPrinter/Parenthesizer.olean", + "object_sha256": "758834573a993ea56fe21eb01fdf952cc961b6fdf25a483d8c421a21ae049c0a", + "object_bytes": 1261744, + "imports": [ + "Lean.Parser.Extension", + "Lean.Parser.StrInterpolation", + "Lean.ParserCompiler.Attribute", + "Lean.PrettyPrinter.Basic", + "Lean.PrettyPrinter.Delaborator.Options" + ] + }, + { + "module": "Lean.PrettyPrinter.Formatter", + "root": "lean", + "source_path": "src/lean/Lean/PrettyPrinter/Formatter.lean", + "source_sha256": "9f23a4454cebb654b89b1365586bef5677ee6a19016a29d2c153abf831e80551", + "object_path": "lib/lean/Lean/PrettyPrinter/Formatter.olean", + "object_sha256": "e923d753ed5f7f143267c1a7fd35a6963cbc13385b0931c920e3652090d46629", + "object_bytes": 1290600, + "imports": [ + "Lean.CoreM", + "Lean.Parser.Extension", + "Lean.Parser.StrInterpolation", + "Lean.KeyedDeclsAttribute", + "Lean.ParserCompiler.Attribute", + "Lean.PrettyPrinter.Basic" + ] + }, + { + "module": "Lean.Parser.Extra", + "root": "lean", + "source_path": "src/lean/Lean/Parser/Extra.lean", + "source_sha256": "735dac230b068564dc278e846767d52dae0218065f91ad1d431c1f0ff43af94d", + "object_path": "lib/lean/Lean/Parser/Extra.olean", + "object_sha256": "4040582414c56f0c594d09842a2ffe65e9a8a89d91fe303cee7641198bbd4482", + "object_bytes": 1032264, + "imports": [ + "Lean.Parser.Extension", + "Lean.PrettyPrinter.Parenthesizer", + "Lean.PrettyPrinter.Formatter" + ] + }, + { + "module": "Lean.Parser.Level", + "root": "lean", + "source_path": "src/lean/Lean/Parser/Level.lean", + "source_sha256": "93a0a5b743bc63656db4a8433c946c17520e1cb94cba0f9bb70833e392786b75", + "object_path": "lib/lean/Lean/Parser/Level.olean", + "object_sha256": "34f2407253c302e38cf104f1b4d48dbaf74e14ea61763bc1468534bd83ad4e75", + "object_bytes": 246416, + "imports": [ + "Lean.Parser.Extra" + ] + }, + { + "module": "Lean.Parser.Attr", + "root": "lean", + "source_path": "src/lean/Lean/Parser/Attr.lean", + "source_sha256": "b9d4b8b4a549ddf7c9b6ec79a682474388fea2acdffc3bcce25fb6a6a276f7d8", + "object_path": "lib/lean/Lean/Parser/Attr.olean", + "object_sha256": "0c2df64bf569c4d8217317d312d1dd14a10060589858687263039db5e16d5ddd", + "object_bytes": 473424, + "imports": [ + "Lean.Parser.Basic", + "Lean.Parser.Extra" + ] + }, + { + "module": "Lean.Parser.Term.Doc", + "root": "lean", + "source_path": "src/lean/Lean/Parser/Term/Doc.lean", + "source_sha256": "2ea807974c5b3f4006cf25d2e14bbc5968e7456622594dda827b169db28da674", + "object_path": "lib/lean/Lean/Parser/Term/Doc.olean", + "object_sha256": "886f82c3557823f6fbd86a76bcc8478bcb1859400d0cb347f53a942f97be5d0c", + "object_bytes": 265888, + "imports": [ + "Lean.Parser.Extension" + ] + }, + { + "module": "Lean.Parser.Term", + "root": "lean", + "source_path": "src/lean/Lean/Parser/Term.lean", + "source_sha256": "67d2bcfa4594e50166254bdee6c09231867fee7eb40504469d88482f549afa6b", + "object_path": "lib/lean/Lean/Parser/Term.olean", + "object_sha256": "79af8e8ab6b32c63facfa5f5fc3cf962c2de91ae07d43311043561f9de32de06", + "object_bytes": 4874480, + "imports": [ + "Lean.Parser.Attr", + "Lean.Parser.Level", + "Lean.Parser.Term.Doc" + ] + }, + { + "module": "Lean.Parser.Tactic.Doc", + "root": "lean", + "source_path": "src/lean/Lean/Parser/Tactic/Doc.lean", + "source_sha256": "7353a657da946bb43bad35f6d96e19cdcf2182a39ff30b74cf21b66cf1d560e5", + "object_path": "lib/lean/Lean/Parser/Tactic/Doc.olean", + "object_sha256": "8e150e993d2f7a01ef73ae6b4382b5e96a4b6d5bea5818ec21412e654c446a49", + "object_bytes": 1009832, + "imports": [ + "Lean.Attributes", + "Lean.DocString.Extension", + "Lean.Elab.InfoTree.Main", + "Lean.Parser.Attr", + "Lean.Parser.Extension" + ] + }, + { + "module": "Lean.Parser.Tactic", + "root": "lean", + "source_path": "src/lean/Lean/Parser/Tactic.lean", + "source_sha256": "485b37796e4f608586970a530253fdf589ca58fa09a1853167719948b572c55e", + "object_path": "lib/lean/Lean/Parser/Tactic.olean", + "object_sha256": "4338e9ff65cbbcf54f1e2a65a9fe4278f0ef5b0553bcab1e8b9b20da7dc9020a", + "object_bytes": 235760, + "imports": [ + "Lean.Parser.Term", + "Lean.Parser.Tactic.Doc" + ] + }, + { + "module": "Lean.Parser.Do", + "root": "lean", + "source_path": "src/lean/Lean/Parser/Do.lean", + "source_sha256": "6189aa513ab26144bd6c459aa69e7d85d1c563cb49b14df10318ced13db008e2", + "object_path": "lib/lean/Lean/Parser/Do.olean", + "object_sha256": "9c392b5f98b97ea6e9723a83c20d965c4d97b3ecbd8fec404a0a476a67b97c76", + "object_bytes": 1570768, + "imports": [ + "Lean.Parser.Term" + ] + }, + { + "module": "Lean.Parser.Command", + "root": "lean", + "source_path": "src/lean/Lean/Parser/Command.lean", + "source_sha256": "70e741010242b2c44fa460479a4fe403a8c0d80a84b3c669d834ad6678913efd", + "object_path": "lib/lean/Lean/Parser/Command.olean", + "object_sha256": "ad66d911dc7f83d55ba7e4b7fb9f8dad4e66c3f958e8fbde5fb57d2e0e63b7b0", + "object_bytes": 3044984, + "imports": [ + "Lean.Parser.Term", + "Lean.Parser.Do" + ] + }, + { + "module": "Lean.Parser.Module", + "root": "lean", + "source_path": "src/lean/Lean/Parser/Module.lean", + "source_sha256": "27c94c410781f6fd2202dab812d9c0d48216523816434984445e67bbe076f25a", + "object_path": "lib/lean/Lean/Parser/Module.olean", + "object_sha256": "fdd1fa5f7e56020a6a4ef0aa8eaaff8e80282a29d3acbe7688db78a1d853d0a1", + "object_bytes": 585192, + "imports": [ + "Lean.Message", + "Lean.Parser.Command" + ] + }, + { + "module": "Lean.Parser.Syntax", + "root": "lean", + "source_path": "src/lean/Lean/Parser/Syntax.lean", + "source_sha256": "4af962d0c6ce784ac85fa585115a097d5b4ab22a488378ac153733482606a12b", + "object_path": "lib/lean/Lean/Parser/Syntax.olean", + "object_sha256": "55c774f67fba6c61fca6699e54d42c0011efbc274130cef124bf5d17ac80637b", + "object_bytes": 1217760, + "imports": [ + "Lean.Parser.Command" + ] + }, + { + "module": "Lean.Parser", + "root": "lean", + "source_path": "src/lean/Lean/Parser.lean", + "source_sha256": "07eb634f0c3b266405e0cc521f00e469684e7ff2b4d42bb52da5b5bfb1c12131", + "object_path": "lib/lean/Lean/Parser.olean", + "object_sha256": "c16b5c7ed5b0624c8c9a5c716f1138f3cdda1e0a0ac344ea6663c7840fedeeff", + "object_bytes": 668280, + "imports": [ + "Lean.Parser.Basic", + "Lean.Parser.Level", + "Lean.Parser.Term", + "Lean.Parser.Tactic", + "Lean.Parser.Command", + "Lean.Parser.Module", + "Lean.Parser.Syntax", + "Lean.Parser.Do", + "Lean.Parser.Tactic.Doc" + ] + }, + { + "module": "Lean.Elab.Import", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Import.lean", + "source_sha256": "c58c89f0107d9760a45832038f4a8e86ad2595901324ad62d060a34b3802439c", + "object_path": "lib/lean/Lean/Elab/Import.olean", + "object_sha256": "194b203ba9aa6146491b3e30bab69e163e5ff9d021762ac9a272c7548ff3b0c5", + "object_bytes": 288272, + "imports": [ + "Lean.Parser.Module", + "Lean.Util.Paths", + "Lean.CoreM" + ] + }, + { + "module": "Lean.Elab.Config", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Config.lean", + "source_sha256": "ab4e40037a60aebd3bb360efd39443e1390d2567c495cebe68ff35e60032c6af", + "object_path": "lib/lean/Lean/Elab/Config.olean", + "object_sha256": "3e3c00c2e32934f5c97fa5818b3624bbba499bdb1104473dd65987627dcd8620", + "object_bytes": 33048, + "imports": [ + "Lean.Meta.Basic" + ] + }, + { + "module": "Lean.SubExpr", + "root": "lean", + "source_path": "src/lean/Lean/SubExpr.lean", + "source_sha256": "7e5a768483f77dd97d114a789b68e0787bffbd27104f9a19d2c74f301a2e4078", + "object_path": "lib/lean/Lean/SubExpr.olean", + "object_sha256": "2745e5e1bdfc24ebf75cdc4f3c65bd984e7cf7e5b7afe617fb4db74b56500736", + "object_bytes": 551456, + "imports": [ + "Lean.Meta.Basic", + "Lean.Data.Json", + "Lean.Data.RBMap", + "Init.Control.Option" + ] + }, + { + "module": "Lean.PrettyPrinter.Delaborator.SubExpr", + "root": "lean", + "source_path": "src/lean/Lean/PrettyPrinter/Delaborator/SubExpr.lean", + "source_sha256": "86e6167acdffa9018b5b938d761691e852f3749cca8fc6be980f976a9c9fd49a", + "object_path": "lib/lean/Lean/PrettyPrinter/Delaborator/SubExpr.olean", + "object_sha256": "9b6e48d935c6708a9f139e1ff48677d255677cd0d795e0b0dd1aa2ac710dc981", + "object_bytes": 553936, + "imports": [ + "Lean.Meta.Basic", + "Lean.SubExpr", + "Lean.Data.RBMap" + ] + }, + { + "module": "Lean.Meta.AbstractMVars", + "root": "lean", + "source_path": "src/lean/Lean/Meta/AbstractMVars.lean", + "source_sha256": "730718ddf834b0586ea8bd78fecd690dfbbd3ea04f4c4908838113db65b9b31b", + "object_path": "lib/lean/Lean/Meta/AbstractMVars.olean", + "object_sha256": "2e08cd57a2ae9b237c7b6027729778d9010ceece3368ca4e9c92619479859b3d", + "object_bytes": 564848, + "imports": [ + "Lean.Meta.Basic" + ] + }, + { + "module": "Lean.Meta.Sorry", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Sorry.lean", + "source_sha256": "c1e85c59d746bfef53ce5767083eb9329e682600a669f9f7296f22aac257849f", + "object_path": "lib/lean/Lean/Meta/Sorry.olean", + "object_sha256": "9044daccef1d18a0fde8d55e326fe642b7958bec5faf5e78abe66cf994c0aa85", + "object_bytes": 206904, + "imports": [ + "Lean.Data.Lsp.Utf16", + "Lean.Meta.InferType", + "Lean.Util.Recognizers" + ] + }, + { + "module": "Lean.Meta.Check", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Check.lean", + "source_sha256": "087a4d41939b9a3ccbf2a43e449ced0b42deaf09da7307d2e6a4c6e6c76a9512", + "object_path": "lib/lean/Lean/Meta/Check.olean", + "object_sha256": "481ddcd76f50b31b9ffbe240ce0e6aabd9766eaca514e4f64e6fe51252dd36f1", + "object_bytes": 1589024, + "imports": [ + "Lean.Meta.InferType", + "Lean.Meta.Sorry" + ] + }, + { + "module": "Lean.Meta.SynthInstance", + "root": "lean", + "source_path": "src/lean/Lean/Meta/SynthInstance.lean", + "source_sha256": "58f45553983ab4b189e39cd9b5fef23f7abf645a548f1c63cca31bc90a7384de", + "object_path": "lib/lean/Lean/Meta/SynthInstance.olean", + "object_sha256": "7e1739c0d0ba126e8baf8790effaf8fb5bddcd1d1284cb0bd8f0723eda4aa11e", + "object_bytes": 3023224, + "imports": [ + "Init.Data.Array.InsertionSort", + "Lean.Meta.Basic", + "Lean.Meta.Instances", + "Lean.Meta.AbstractMVars", + "Lean.Meta.Check", + "Lean.Util.Profile" + ] + }, + { + "module": "Lean.Util.FindMVar", + "root": "lean", + "source_path": "src/lean/Lean/Util/FindMVar.lean", + "source_sha256": "73e9cc94422bfdc70eb6f90630f898d163f9ca5cbe885058ef3fad61d1a8a45a", + "object_path": "lib/lean/Lean/Util/FindMVar.olean", + "object_sha256": "0a8bc4d2806577076c14d778b8f42510d9e3ca78d798a18a88fec721ca4a8149", + "object_bytes": 65784, + "imports": [ + "Lean.Expr" + ] + }, + { + "module": "Lean.Util.FindLevelMVar", + "root": "lean", + "source_path": "src/lean/Lean/Util/FindLevelMVar.lean", + "source_sha256": "476bb02fa1077edf625bc1a1a5ccd9cc3ee16664b0edaa0d18d59b8634826773", + "object_path": "lib/lean/Lean/Util/FindLevelMVar.olean", + "object_sha256": "51edbcc58050143355ed8440216c28fe24bc98925e71383b8ddb75c677a62f66", + "object_bytes": 103120, + "imports": [ + "Lean.Expr" + ] + }, + { + "module": "Lean.Util.ReplaceLevel", + "root": "lean", + "source_path": "src/lean/Lean/Util/ReplaceLevel.lean", + "source_sha256": "435400ae86976c70a84e5d629e27e1b315bfb8c1bcd56deb65060dbcc3638543", + "object_path": "lib/lean/Lean/Util/ReplaceLevel.olean", + "object_sha256": "640f08c880b033439bc717838393c09457e16fceea384ab133c48906dc5b36a8", + "object_bytes": 219096, + "imports": [ + "Lean.Expr" + ] + }, + { + "module": "Lean.PrettyPrinter.Delaborator.Attributes", + "root": "lean", + "source_path": "src/lean/Lean/PrettyPrinter/Delaborator/Attributes.lean", + "source_sha256": "0aba31ae7375b1f6c4c0abbc6ee527595c7a6c3cd9daea0489ac3c360b7be295", + "object_path": "lib/lean/Lean/PrettyPrinter/Delaborator/Attributes.olean", + "object_sha256": "5c2f8ddd4eb1efe24d275b962edea1c6286418f03ca4f5b20c4cbbe407a71268", + "object_bytes": 45792, + "imports": [ + "Lean.Attributes" + ] + }, + { + "module": "Lean.PrettyPrinter.Delaborator.FieldNotation", + "root": "lean", + "source_path": "src/lean/Lean/PrettyPrinter/Delaborator/FieldNotation.lean", + "source_sha256": "1f184c13533abe42216de3b785f7e8d1932ea76b5ddaf3cbcd89f8f271a827ef", + "object_path": "lib/lean/Lean/PrettyPrinter/Delaborator/FieldNotation.olean", + "object_sha256": "2014833102ffe6954a7b9ce1ec60dcb636b3a53ec58aa27ee4118c077274f75e", + "object_bytes": 467384, + "imports": [ + "Lean.Meta.InferType", + "Lean.Meta.WHNF", + "Lean.PrettyPrinter.Delaborator.Attributes", + "Lean.PrettyPrinter.Delaborator.Options", + "Lean.Structure" + ] + }, + { + "module": "Lean.PrettyPrinter.Delaborator.TopDownAnalyze", + "root": "lean", + "source_path": "src/lean/Lean/PrettyPrinter/Delaborator/TopDownAnalyze.lean", + "source_sha256": "dda8f3333c77593d7bcb1ed9f434aeb6ab40eb84a0e8e6b6d0aa50dde8b6a798", + "object_path": "lib/lean/Lean/PrettyPrinter/Delaborator/TopDownAnalyze.olean", + "object_sha256": "a899692ded22b6662ba86f4e261a43c4ae26d10788ca8ea28ca9265faa4a58b1", + "object_bytes": 2504864, + "imports": [ + "Lean.Data.RBMap", + "Lean.Meta.SynthInstance", + "Lean.Meta.CtorRecognizer", + "Lean.Util.FindMVar", + "Lean.Util.FindLevelMVar", + "Lean.Util.CollectLevelParams", + "Lean.Util.ReplaceLevel", + "Lean.PrettyPrinter.Delaborator.FieldNotation", + "Lean.PrettyPrinter.Delaborator.Options", + "Lean.PrettyPrinter.Delaborator.SubExpr", + "Lean.Elab.Config" + ] + }, + { + "module": "Lean.PrettyPrinter.Delaborator.Basic", + "root": "lean", + "source_path": "src/lean/Lean/PrettyPrinter/Delaborator/Basic.lean", + "source_sha256": "1598f9500cedf01dd19bce74a6a272ab8468898b38efbb18c6ecb0659b70e8af", + "object_path": "lib/lean/Lean/PrettyPrinter/Delaborator/Basic.olean", + "object_sha256": "e9f9e696893598c55dc27ce953609b80bc1e29b0d92811b1ec35e01f88e10346", + "object_bytes": 1283216, + "imports": [ + "Lean.KeyedDeclsAttribute", + "Lean.PrettyPrinter.Delaborator.Options", + "Lean.PrettyPrinter.Delaborator.SubExpr", + "Lean.PrettyPrinter.Delaborator.TopDownAnalyze" + ] + }, + { + "module": "Lean.Meta.CoeAttr", + "root": "lean", + "source_path": "src/lean/Lean/Meta/CoeAttr.lean", + "source_sha256": "7724c3fdc518e8458901c42ff7b46611393cde7838d57a13dc6a092e73e30866", + "object_path": "lib/lean/Lean/Meta/CoeAttr.olean", + "object_sha256": "f50fd1e3096b8f2b3ec935312fdbe199923426d4f044d6a7bb3085a5c7c416e3", + "object_bytes": 383952, + "imports": [ + "Lean.Attributes", + "Lean.ScopedEnvExtension", + "Lean.Meta.FunInfo" + ] + }, + { + "module": "Lean.Meta.AppBuilder", + "root": "lean", + "source_path": "src/lean/Lean/Meta/AppBuilder.lean", + "source_sha256": "caed5aeac9954d741fa7fc907d99c6cad0b9cb1b4a1e3203799ae8a89091bb3c", + "object_path": "lib/lean/Lean/Meta/AppBuilder.olean", + "object_sha256": "fabcd16a72f3e8ac409927fb0bcdf2ea1fc92e695f39bcbc6e9c21d1cd558ebc", + "object_bytes": 1844080, + "imports": [ + "Lean.Structure", + "Lean.Meta.SynthInstance", + "Lean.Meta.Check", + "Lean.Meta.DecLevel" + ] + }, + { + "module": "Lean.Meta.Structure", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Structure.lean", + "source_sha256": "f43d64dbc14bc4b61e0f9163bd2bf5fcf7df1ba605402402fc14a290a845cf7a", + "object_path": "lib/lean/Lean/Meta/Structure.olean", + "object_sha256": "e557eee7b959d3d24ffa69f79bec0888499f4e4108d07bc78e3544263e60de96", + "object_bytes": 904760, + "imports": [ + "Lean.AddDecl", + "Lean.Structure", + "Lean.Meta.AppBuilder" + ] + }, + { + "module": "Lean.PrettyPrinter.Delaborator.Builtins", + "root": "lean", + "source_path": "src/lean/Lean/PrettyPrinter/Delaborator/Builtins.lean", + "source_sha256": "be28a8d07aba816b9cb5de4c3f15201b3ba72ce2b03397ed82e256d808ddce57", + "object_path": "lib/lean/Lean/PrettyPrinter/Delaborator/Builtins.olean", + "object_sha256": "ffe22b133a157eb1cc2f880721a0996b49a80773895f6d88369671d042e74b05", + "object_bytes": 5540504, + "imports": [ + "Lean.PrettyPrinter.Delaborator.Attributes", + "Lean.PrettyPrinter.Delaborator.Basic", + "Lean.PrettyPrinter.Delaborator.SubExpr", + "Lean.PrettyPrinter.Delaborator.TopDownAnalyze", + "Lean.Parser.Do", + "Lean.Parser.Command", + "Lean.Meta.CoeAttr", + "Lean.Meta.Structure" + ] + }, + { + "module": "Lean.PrettyPrinter.Delaborator", + "root": "lean", + "source_path": "src/lean/Lean/PrettyPrinter/Delaborator.lean", + "source_sha256": "09fc9ae176ab0f755c0647fb3f4d02ff3a7c95f7c94e019b5c3491042f17c5f1", + "object_path": "lib/lean/Lean/PrettyPrinter/Delaborator.olean", + "object_sha256": "8d2ca1ffb9c4122581902f2e360511fca05e9e4cac5832e98f67fd3f408e37a0", + "object_bytes": 18248, + "imports": [ + "Lean.PrettyPrinter.Delaborator.Options", + "Lean.PrettyPrinter.Delaborator.SubExpr", + "Lean.PrettyPrinter.Delaborator.TopDownAnalyze", + "Lean.PrettyPrinter.Delaborator.Basic", + "Lean.PrettyPrinter.Delaborator.Builtins" + ] + }, + { + "module": "Lean.Meta.ReduceEval", + "root": "lean", + "source_path": "src/lean/Lean/Meta/ReduceEval.lean", + "source_sha256": "96ccfdebf2bbd67dca61b16ac00d04ea43e3a49f0707200c24bd04f1899b465a", + "object_path": "lib/lean/Lean/Meta/ReduceEval.olean", + "object_sha256": "b95588a16f2bff2b0e045977399f18576a4458b8bfd0a6b2819e9c1b838382ab", + "object_bytes": 343800, + "imports": [ + "Lean.Meta.Offset" + ] + }, + { + "module": "Lean.ParserCompiler", + "root": "lean", + "source_path": "src/lean/Lean/ParserCompiler.lean", + "source_sha256": "523561783945ec02a356e48f36478a82ba96124d1e12f9a9a02c01e38b04d1e1", + "object_path": "lib/lean/Lean/ParserCompiler.olean", + "object_sha256": "64feba0daede2a42e56478b0d911fc09195d0931622b1ea4847ee520f3b147e3", + "object_bytes": 2412944, + "imports": [ + "Lean.Meta.ReduceEval", + "Lean.Meta.WHNF", + "Lean.KeyedDeclsAttribute", + "Lean.ParserCompiler.Attribute", + "Lean.Parser.Extension" + ] + }, + { + "module": "Lean.Util.NumObjs", + "root": "lean", + "source_path": "src/lean/Lean/Util/NumObjs.lean", + "source_sha256": "b4ec8eae508d86ca8fc081e014b98e0673ac1700cb3b34d8babbbcda79b45f0f", + "object_path": "lib/lean/Lean/Util/NumObjs.olean", + "object_sha256": "18d4e0828903ab7488081e568ae3316cb9a77da224487f0afaaa9b56451fac34", + "object_bytes": 172704, + "imports": [ + "Lean.Expr", + "Lean.Util.PtrSet" + ] + }, + { + "module": "Lean.Util.ShareCommon", + "root": "lean", + "source_path": "src/lean/Lean/Util/ShareCommon.lean", + "source_sha256": "753457c5cb552345418ce7c7774c32b051a2eba4e97d92456c8b634ab88672cc", + "object_path": "lib/lean/Lean/Util/ShareCommon.olean", + "object_sha256": "dfb72a98980d6ef7aa5b86a57e7809a904141d51f06b19694fad3c70b9cb0f09", + "object_bytes": 212536, + "imports": [ + "Init.ShareCommon", + "Std.Data.HashSet.Basic", + "Std.Data.HashMap.Basic", + "Lean.Data.PersistentHashMap", + "Lean.Data.PersistentHashSet" + ] + }, + { + "module": "Lean.PrettyPrinter", + "root": "lean", + "source_path": "src/lean/Lean/PrettyPrinter.lean", + "source_sha256": "26ca292ed0cec82d6e168ad6e4acb5cec0524664cf4bf6caa6347a1861758c4c", + "object_path": "lib/lean/Lean/PrettyPrinter.olean", + "object_sha256": "41124fea84d98432b2541d465790625f834dff220e7f7f8aa75a2b65476feb52", + "object_bytes": 627544, + "imports": [ + "Lean.PrettyPrinter.Delaborator", + "Lean.PrettyPrinter.Parenthesizer", + "Lean.PrettyPrinter.Formatter", + "Lean.Parser.Module", + "Lean.ParserCompiler", + "Lean.Util.NumObjs", + "Lean.Util.ShareCommon" + ] + }, + { + "module": "Lean.Meta.Diagnostics", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Diagnostics.lean", + "source_sha256": "49e6b329ad5fb90815e9415169c85f237bd27bd9edbea4cd92b35a8d24984c61", + "object_path": "lib/lean/Lean/Meta/Diagnostics.olean", + "object_sha256": "7073a97edaac4c5d610ae82682360d4d32ca03ed0efcc540ba95fde343698be5", + "object_bytes": 541848, + "imports": [ + "Lean.PrettyPrinter", + "Lean.Meta.Basic", + "Lean.Meta.Instances" + ] + }, + { + "module": "Lean.Meta.Coe", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Coe.lean", + "source_sha256": "e7d598fc265dbeba701579a444ccd6ed9edbcf18121982210b3ef1fef5912175", + "object_path": "lib/lean/Lean/Meta/Coe.olean", + "object_sha256": "6da0c04ac4c265d7d5076782dcd508cc77b3d1d7d6197539c31bed946595e9b2", + "object_bytes": 1536616, + "imports": [ + "Lean.Meta.Transform", + "Lean.Meta.SynthInstance", + "Lean.Meta.AppBuilder" + ] + }, + { + "module": "Lean.Util.CollectLevelMVars", + "root": "lean", + "source_path": "src/lean/Lean/Util/CollectLevelMVars.lean", + "source_sha256": "8105a79e7cb2822fbc80238800c34c594b17d68ebdc22c4854108542c845a7fc", + "object_path": "lib/lean/Lean/Util/CollectLevelMVars.olean", + "object_sha256": "84189fb4d5b949855b65987e96a9b557fe35e9c5a6ba989852bec152b563fb37", + "object_bytes": 219008, + "imports": [ + "Lean.Expr" + ] + }, + { + "module": "Lean.Linter.Basic", + "root": "lean", + "source_path": "src/lean/Lean/Linter/Basic.lean", + "source_sha256": "6ec44d4c79b0d18565a8cc02fad554b7eab7a6e8e724d5417d309fa42890d5fe", + "object_path": "lib/lean/Lean/Linter/Basic.olean", + "object_sha256": "10513a71760799423b326681c6be7c12f90d20789c71bc9578bd6afa64eeff29", + "object_bytes": 211416, + "imports": [ + "Lean.Data.Options", + "Lean.MonadEnv", + "Lean.Log" + ] + }, + { + "module": "Lean.Linter.Deprecated", + "root": "lean", + "source_path": "src/lean/Lean/Linter/Deprecated.lean", + "source_sha256": "5cdeb7df5e9236fa61bae776b08cba4134d5303b00564c58f35b31b588f7504c", + "object_path": "lib/lean/Lean/Linter/Deprecated.olean", + "object_sha256": "16209d4edb166cf6e038dbaa39bd8375e838132b86008d78fa61bd05b4cfcfd9", + "object_bytes": 312800, + "imports": [ + "Lean.Linter.Basic", + "Lean.Attributes", + "Lean.Elab.InfoTree.Main" + ] + }, + { + "module": "Lean.Elab.AutoBound", + "root": "lean", + "source_path": "src/lean/Lean/Elab/AutoBound.lean", + "source_sha256": "728f1d5857766f66e87bdb373f827f68fd3d597ced976597225560f7ee3ce280", + "object_path": "lib/lean/Lean/Elab/AutoBound.olean", + "object_sha256": "9ba3a04033de790d45a352928b51b4b7fe6058b9f0a2946a29725d5cd22ec682", + "object_bytes": 95096, + "imports": [ + "Lean.Data.Options" + ] + }, + { + "module": "Lean.Elab.Level", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Level.lean", + "source_sha256": "f9f3ea17b4eee17950995130dd9412189d5a89bd7e8baeb2e383b6b33e0d9ba6", + "object_path": "lib/lean/Lean/Elab/Level.olean", + "object_sha256": "0399a1280b19a09f1173a6688cac006b9275593a55dd5e5d841d85594aadb8d1", + "object_bytes": 333840, + "imports": [ + "Lean.Log", + "Lean.Parser.Level", + "Lean.Elab.Exception", + "Lean.Elab.AutoBound" + ] + }, + { + "module": "Lean.Elab.Util", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Util.lean", + "source_sha256": "78c48207f9f862e883a35849a5c8acb85c848a744c35cff037a64ea818e0e6fe", + "object_path": "lib/lean/Lean/Elab/Util.olean", + "object_sha256": "781a1d24bc9a49bde9f88fe2e9071cfa5374f1d631e2c9a14fb40716483ca07e", + "object_bytes": 623320, + "imports": [ + "Lean.Parser.Command", + "Lean.KeyedDeclsAttribute", + "Lean.Elab.Exception" + ] + }, + { + "module": "Lean.Elab.Attributes", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Attributes.lean", + "source_sha256": "b02f148c9b57336d8e4559e13cd3ff62efd8a7391827b033eb18bd6c46e7e3b0", + "object_path": "lib/lean/Lean/Elab/Attributes.olean", + "object_sha256": "35c90e851e6514175fa2e4e9caeefa21783611a1fd55db9ce3373e0a0f1b8662", + "object_bytes": 349712, + "imports": [ + "Lean.Elab.Util" + ] + }, + { + "module": "Lean.DocString.Add", + "root": "lean", + "source_path": "src/lean/Lean/DocString/Add.lean", + "source_sha256": "a4f4b75059ae25a650f8d5118287d897287b97dc8f3bd42db347ddd5ccab2bdb", + "object_path": "lib/lean/Lean/DocString/Add.olean", + "object_sha256": "10b8708b6b0f32eef8ab119839d2038cd100a4788f19f27e97e9326ff9100ba0", + "object_bytes": 155416, + "imports": [ + "Lean.Environment", + "Lean.Exception", + "Lean.Log", + "Lean.DocString.Extension", + "Lean.DocString.Links" + ] + }, + { + "module": "Lean.Elab.DeclModifiers", + "root": "lean", + "source_path": "src/lean/Lean/Elab/DeclModifiers.lean", + "source_sha256": "7fdd8b5da82ab8c93d4109f915ac41e207acbbd8ed1499c1ff2c096db9bf4057", + "object_path": "lib/lean/Lean/Elab/DeclModifiers.olean", + "object_sha256": "31eb5079fc837134c16048ba10299fcfa0dd40986ac5fcfb267255544a908192", + "object_bytes": 717464, + "imports": [ + "Lean.Structure", + "Lean.Elab.Attributes", + "Lean.DocString.Add" + ] + }, + { + "module": "Lean.Elab.PreDefinition.TerminationHint", + "root": "lean", + "source_path": "src/lean/Lean/Elab/PreDefinition/TerminationHint.lean", + "source_sha256": "bbf1fd7c62bf609619bdab17660a0348e6219831af3023d71807d869ffcea1ee", + "object_path": "lib/lean/Lean/Elab/PreDefinition/TerminationHint.olean", + "object_sha256": "8d06581345ebfe6c6cf0da2035e835007f3ebfbbe84fa87451617c524c938ff4", + "object_bytes": 736336, + "imports": [ + "Lean.Parser.Term" + ] + }, + { + "module": "Lean.Elab.DeclarationRange", + "root": "lean", + "source_path": "src/lean/Lean/Elab/DeclarationRange.lean", + "source_sha256": "38087c6b75385ef596baa475b8158aad942a9cd4e19670c23e0a9d8223d20b3d", + "object_path": "lib/lean/Lean/Elab/DeclarationRange.olean", + "object_sha256": "65358ef83aa996998996c126a3662140830fca1475071780eb9912d5301cc427", + "object_bytes": 97712, + "imports": [ + "Lean.Log", + "Lean.Parser.Command", + "Lean.DeclarationRange", + "Lean.Data.Lsp.Utf16" + ] + }, + { + "module": "Lean.Elab.InfoTree.InlayHints", + "root": "lean", + "source_path": "src/lean/Lean/Elab/InfoTree/InlayHints.lean", + "source_sha256": "fd489efcca8ee07c975faa149d3802692ad10f2ad8ea2e9d4d3ff9f0cd65935b", + "object_path": "lib/lean/Lean/Elab/InfoTree/InlayHints.olean", + "object_sha256": "9d891249caf1db0cb8e732a56945fae4d01d0e5e845eeb376404e5ba27a7450b", + "object_bytes": 270872, + "imports": [ + "Lean.Meta.Basic" + ] + }, + { + "module": "Lean.Elab.Term", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Term.lean", + "source_sha256": "57b6fa10fa3329cd2221bdf22723f9846afbffe567439c4eb4a72413204f7c85", + "object_path": "lib/lean/Lean/Elab/Term.olean", + "object_sha256": "9209d5d4ce33ff22055b6979f738986b5db31f1f25bc6cdd41b29370db2d8d3e", + "object_bytes": 6738656, + "imports": [ + "Lean.ReservedNameAction", + "Lean.Meta.AppBuilder", + "Lean.Meta.CollectMVars", + "Lean.Meta.Coe", + "Lean.Util.CollectLevelMVars", + "Lean.Linter.Deprecated", + "Lean.Elab.Config", + "Lean.Elab.Level", + "Lean.Elab.DeclModifiers", + "Lean.Elab.PreDefinition.TerminationHint", + "Lean.Elab.DeclarationRange", + "Lean.Language.Basic", + "Lean.Elab.InfoTree.InlayHints" + ] + }, + { + "module": "Lean.Elab.Quotation.Util", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Quotation/Util.lean", + "source_sha256": "e79368c9e549998e150589cdb4ab1af3e78bfe7a1d01aa3efd3c08f592b7c266", + "object_path": "lib/lean/Lean/Elab/Quotation/Util.olean", + "object_sha256": "267e07d7d46d3960c1623e876c49031a2674fe9101d95aeda36cc7c118e9dd3f", + "object_bytes": 216184, + "imports": [ + "Lean.Elab.Term" + ] + }, + { + "module": "Lean.Elab.Quotation.Precheck", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Quotation/Precheck.lean", + "source_sha256": "be776d3e0d7deaa30880685e2e614904a0518f663f0d8cd746ca93dab2bf62f3", + "object_path": "lib/lean/Lean/Elab/Quotation/Precheck.olean", + "object_sha256": "37618bf9c14d0a75f493b1ebe11f9c731268e6cb1f858205bb8006aaa33a8b94", + "object_bytes": 714496, + "imports": [ + "Lean.KeyedDeclsAttribute", + "Lean.Parser.Command", + "Lean.Elab.Term", + "Lean.Elab.Quotation.Util" + ] + }, + { + "module": "Lean.Elab.BindersUtil", + "root": "lean", + "source_path": "src/lean/Lean/Elab/BindersUtil.lean", + "source_sha256": "63d6563fe8c51aa1b30fe3b0904db520ee279ee6fe1d3c94e007d5e7210fe9f4", + "object_path": "lib/lean/Lean/Elab/BindersUtil.olean", + "object_sha256": "80ee8a923b3d83ff28e1cee02b16ae96350767215f24d7005ac89f65bb251fc4", + "object_bytes": 322144, + "imports": [ + "Lean.Parser.Term" + ] + }, + { + "module": "Lean.Meta.Tactic.Util", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Util.lean", + "source_sha256": "d56b9e7c8c2861234f4c1b01be11ff7e49257092c880ab1fd25ca8c3a43b662f", + "object_path": "lib/lean/Lean/Meta/Tactic/Util.olean", + "object_sha256": "dbb8c152565d6588c7714f98f1c5c95907474fa11b97f24cc0345a6fe138a872", + "object_bytes": 777512, + "imports": [ + "Lean.Util.ForEachExprWhere", + "Lean.Meta.Basic", + "Lean.Meta.AppBuilder", + "Lean.Meta.PPGoal" + ] + }, + { + "module": "Lean.Util.ForEachExpr", + "root": "lean", + "source_path": "src/lean/Lean/Util/ForEachExpr.lean", + "source_sha256": "ae6b05c88e84a836e8340700273d41e1269706ce0d4b129cc59c49415b8fb5ab", + "object_path": "lib/lean/Lean/Util/ForEachExpr.olean", + "object_sha256": "1ba13b2ee2ef993608cd94706ac9f0cc0887cf158709a9c94b16f33529ede0fe", + "object_bytes": 249552, + "imports": [ + "Lean.Expr", + "Lean.Util.MonadCache" + ] + }, + { + "module": "Lean.Util.OccursCheck", + "root": "lean", + "source_path": "src/lean/Lean/Util/OccursCheck.lean", + "source_sha256": "4220d646b99fb0fb1e160a0cab6572e187b30fd525a9316eb4377d3545fd389e", + "object_path": "lib/lean/Lean/Util/OccursCheck.olean", + "object_sha256": "98b0008e161989a6f4a687ad049e0eb64469e95232e74d8c4e43d5e608e019d2", + "object_bytes": 249408, + "imports": [ + "Lean.MetavarContext" + ] + }, + { + "module": "Lean.Elab.Tactic.Basic", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/Basic.lean", + "source_sha256": "e6d8e5a63c532c5dadc25dc6cd1ba0d0ae81a5f7a1da99be8d1964127156fbd1", + "object_path": "lib/lean/Lean/Elab/Tactic/Basic.olean", + "object_sha256": "ecc4f70903bf069351c71a0eaf2e71dfcf5abfdc20d1a0814e5ad6804222f8d2", + "object_bytes": 1982568, + "imports": [ + "Lean.Meta.Tactic.Util", + "Lean.Elab.Term" + ] + }, + { + "module": "Lean.Elab.SyntheticMVars", + "root": "lean", + "source_path": "src/lean/Lean/Elab/SyntheticMVars.lean", + "source_sha256": "78e36745d6c78c1cf984bf4985b1e8dfbd0ea78094c3194fac60cb9c9eb47233", + "object_path": "lib/lean/Lean/Elab/SyntheticMVars.olean", + "object_sha256": "0ed6678b07b22c72ff0130abd57fc37f5eeb896e011f11f68a9895f4b134fca1", + "object_bytes": 2227112, + "imports": [ + "Lean.Meta.Tactic.Util", + "Lean.Util.NumObjs", + "Lean.Util.ForEachExpr", + "Lean.Util.OccursCheck", + "Lean.Elab.Tactic.Basic" + ] + }, + { + "module": "Lean.Meta.Tactic.AuxLemma", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/AuxLemma.lean", + "source_sha256": "d6d97a2f222caa2037b9215f7c9ac30213b5a66a55cf485aef101b6d27681172", + "object_path": "lib/lean/Lean/Meta/Tactic/AuxLemma.olean", + "object_sha256": "3ab7fc9bcf0b5875f3ec9bbe38f7fa370db545c2916f8afd04438fec37627235", + "object_bytes": 229912, + "imports": [ + "Lean.AddDecl", + "Lean.Meta.Basic" + ] + }, + { + "module": "Lean.Meta.Closure", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Closure.lean", + "source_sha256": "879f70345ff7dbaa33b191811335a3225c3b275cd22da99bc14b35280e45975c", + "object_path": "lib/lean/Lean/Meta/Closure.olean", + "object_sha256": "b8d832d92b2263e0947f930ecab8652418e62d733f876ec6515d4b86772158ee", + "object_bytes": 1919104, + "imports": [ + "Lean.MetavarContext", + "Lean.Environment", + "Lean.AddDecl", + "Lean.Util.FoldConsts", + "Lean.Meta.Basic", + "Lean.Meta.Check", + "Lean.Meta.Tactic.AuxLemma" + ] + }, + { + "module": "Lean.Meta.RecursorInfo", + "root": "lean", + "source_path": "src/lean/Lean/Meta/RecursorInfo.lean", + "source_sha256": "2fcd9b9abe2624e1924b0f79f8c508460a41f59abe934cd54b7aa5949936d5ec", + "object_path": "lib/lean/Lean/Meta/RecursorInfo.olean", + "object_sha256": "ab0e2b3b2a3227c6343cf0c8134c43f2905e1b3871612e6da7fcfbd9158b0eef", + "object_bytes": 1050744, + "imports": [ + "Lean.AuxRecursor", + "Lean.Util.FindExpr", + "Lean.Meta.Basic" + ] + }, + { + "module": "Lean.Meta.Tactic.Clear", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Clear.lean", + "source_sha256": "7700ce2f8e281ce4a68adf4d0a4cfe9ce0bf265b1d97d5b4a73452a1db804b8c", + "object_path": "lib/lean/Lean/Meta/Tactic/Clear.olean", + "object_sha256": "0b8d87b13a74083b2f24fee64a9700212734ae4e9128926939c7fac29f177a4f", + "object_bytes": 337696, + "imports": [ + "Lean.Meta.Tactic.Util" + ] + }, + { + "module": "Lean.Meta.Tactic.Revert", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Revert.lean", + "source_sha256": "93acfbc0c5a0e378241bbd4ddf15ea596df79793af7f06a43e8dbd5dfd16dcfd", + "object_path": "lib/lean/Lean/Meta/Tactic/Revert.olean", + "object_sha256": "2ef7758483548d68ed1cc03a2a9f5d68b2c8503569b83d1c1acbe3becb00a471", + "object_bytes": 296384, + "imports": [ + "Lean.Meta.Tactic.Clear" + ] + }, + { + "module": "Lean.Meta.Tactic.Intro", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Intro.lean", + "source_sha256": "81252fc8640299ad5f165523f140d0941375ed0b99dbb576a7368a79ac0db24b", + "object_path": "lib/lean/Lean/Meta/Tactic/Intro.olean", + "object_sha256": "a5688e10c40d6736c3fa1701cadae4f0e84b47cb1ed404a3b43191cb0bef5ad8", + "object_bytes": 457536, + "imports": [ + "Lean.Meta.Tactic.Util" + ] + }, + { + "module": "Lean.Meta.Tactic.FVarSubst", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/FVarSubst.lean", + "source_sha256": "67e3cb62e9f636964937ce532036381ba5bed925ced633e7bacddd879c09878e", + "object_path": "lib/lean/Lean/Meta/Tactic/FVarSubst.olean", + "object_sha256": "3f3ff45843ca540a007954194114e57a79a761216449254ed36c486284dc9014", + "object_bytes": 137440, + "imports": [ + "Lean.Data.AssocList", + "Lean.Expr", + "Lean.LocalContext", + "Lean.Util.ReplaceExpr" + ] + }, + { + "module": "Lean.Meta.Tactic.Induction", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Induction.lean", + "source_sha256": "57af485f101e74e6ac3810469b32bd00c6c5bb70726fc56fdf44f3b318613857", + "object_path": "lib/lean/Lean/Meta/Tactic/Induction.olean", + "object_sha256": "2b342828591383662c19e0083b4f1b458d314a74373f4c6680cedadea75dc6e3", + "object_bytes": 976824, + "imports": [ + "Lean.Meta.RecursorInfo", + "Lean.Meta.SynthInstance", + "Lean.Meta.Tactic.Util", + "Lean.Meta.Tactic.Revert", + "Lean.Meta.Tactic.Intro", + "Lean.Meta.Tactic.Clear", + "Lean.Meta.Tactic.FVarSubst" + ] + }, + { + "module": "Lean.Meta.MatchUtil", + "root": "lean", + "source_path": "src/lean/Lean/Meta/MatchUtil.lean", + "source_sha256": "87afd03e3cb2930824044d408805b89c1925eb555eba0a0574779d71b59a5858", + "object_path": "lib/lean/Lean/Meta/MatchUtil.olean", + "object_sha256": "537d1252be58c656f01024c6886066e8cb889e5710623d93e3abe266fe756c63", + "object_bytes": 217440, + "imports": [ + "Lean.Util.Recognizers", + "Lean.Meta.Basic", + "Lean.Meta.CtorRecognizer" + ] + }, + { + "module": "Lean.Meta.Tactic.Assert", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Assert.lean", + "source_sha256": "be6cea0d58f85ed67bcecdac5873a0a8d369d4eb2eeadb4ff682e74eca6144ea", + "object_path": "lib/lean/Lean/Meta/Tactic/Assert.olean", + "object_sha256": "2ecb48bf120f7bd3ac05417d8f4b9bd01ab0fbf3d5c88ab1b5ad8c1f6bd02983", + "object_bytes": 506888, + "imports": [ + "Lean.Meta.Tactic.FVarSubst", + "Lean.Meta.Tactic.Intro", + "Lean.Meta.Tactic.Revert", + "Lean.Util.ForEachExpr" + ] + }, + { + "module": "Lean.Meta.Tactic.Subst", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Subst.lean", + "source_sha256": "68721acaa62061f8a219e3fcdbfae55d4de9fff7596958591216350f581ce14d", + "object_path": "lib/lean/Lean/Meta/Tactic/Subst.olean", + "object_sha256": "725212a7ad81a150940f4ab7bb29a7769241020f4d40f8e407876710768508cf", + "object_bytes": 1076512, + "imports": [ + "Lean.Meta.AppBuilder", + "Lean.Meta.MatchUtil", + "Lean.Meta.Tactic.Util", + "Lean.Meta.Tactic.Revert", + "Lean.Meta.Tactic.Assert", + "Lean.Meta.Tactic.Intro", + "Lean.Meta.Tactic.Clear", + "Lean.Meta.Tactic.FVarSubst" + ] + }, + { + "module": "Lean.Meta.Tactic.Injection", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Injection.lean", + "source_sha256": "7daa867c23d54b26b0144c96a8d58f71e0726a4e64a0331feddf63e2b6a18898", + "object_path": "lib/lean/Lean/Meta/Tactic/Injection.olean", + "object_sha256": "1b39efa29e978559ccf37498a06300d5575ab894cf4d5eb0551ebf4c5fe13cf3", + "object_bytes": 652752, + "imports": [ + "Lean.Meta.AppBuilder", + "Lean.Meta.MatchUtil", + "Lean.Meta.Tactic.Clear", + "Lean.Meta.Tactic.Subst", + "Lean.Meta.Tactic.Assert", + "Lean.Meta.Tactic.Intro" + ] + }, + { + "module": "Lean.Meta.Tactic.Replace", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Replace.lean", + "source_sha256": "7f40fa244d44da166cb118ae9a360a1acdad437125055bbfd782b6988fdf4c48", + "object_path": "lib/lean/Lean/Meta/Tactic/Replace.olean", + "object_sha256": "23638269e3cf0f6df5bad16ab4c8ee5157908323f554e9d6f7f93cafa0859e05", + "object_bytes": 559152, + "imports": [ + "Lean.Util.ForEachExpr", + "Lean.Elab.InfoTree.Main", + "Lean.Meta.AppBuilder", + "Lean.Meta.MatchUtil", + "Lean.Meta.Tactic.Util", + "Lean.Meta.Tactic.Revert", + "Lean.Meta.Tactic.Intro", + "Lean.Meta.Tactic.Clear", + "Lean.Meta.Tactic.Assert" + ] + }, + { + "module": "Lean.Meta.Tactic.UnifyEq", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/UnifyEq.lean", + "source_sha256": "50f565afb025192d678a5179f461b155e6a90f3e10b98056beeabece36c69334", + "object_path": "lib/lean/Lean/Meta/Tactic/UnifyEq.olean", + "object_sha256": "7a8983a13768a2d9fa6e1fc8d288e48fc42d0087af4d01e1eaa22b86cfc50406", + "object_bytes": 747104, + "imports": [ + "Lean.Meta.Tactic.Injection" + ] + }, + { + "module": "Lean.Meta.ACLt", + "root": "lean", + "source_path": "src/lean/Lean/Meta/ACLt.lean", + "source_sha256": "4295d287194afd677882ed88577dad06adaa799381d613847dcc83ae8039f487", + "object_path": "lib/lean/Lean/Meta/ACLt.olean", + "object_sha256": "62d8da86d3d18e461a4f42bf1ea5beeacaef605a1f4b0b81699ccb6a8a9bb83c", + "object_bytes": 429864, + "imports": [ + "Lean.Meta.Basic", + "Lean.Meta.FunInfo", + "Lean.Meta.DiscrTree" + ] + }, + { + "module": "Lean.Meta.Match.MatchEqsExt", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Match/MatchEqsExt.lean", + "source_sha256": "41043b19a5001e4932c8c84306b9009d626ea840af214c0f2a865d009bdbca94", + "object_path": "lib/lean/Lean/Meta/Match/MatchEqsExt.olean", + "object_sha256": "a51bcf31455ce9f3b9f1ef5cf7072417288a6fbb11fbb9939235a1ce05c65668", + "object_bytes": 248152, + "imports": [ + "Lean.Meta.Basic" + ] + }, + { + "module": "Lean.Meta.CongrTheorems", + "root": "lean", + "source_path": "src/lean/Lean/Meta/CongrTheorems.lean", + "source_sha256": "e2dd4fff41cccf6f116ee11e6c3e9173a7ec7c0935d0a8efcb12608db5eb3b19", + "object_path": "lib/lean/Lean/Meta/CongrTheorems.olean", + "object_sha256": "dbca6ba4b410c563cd74ed8050e51ae1b5c4c5938fbc733a48576a0531010d94", + "object_bytes": 1311840, + "imports": [ + "Lean.AddDecl", + "Lean.ReservedNameAction", + "Lean.ResolveName", + "Lean.Meta.AppBuilder", + "Lean.Class" + ] + }, + { + "module": "Lean.Meta.Eqns", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Eqns.lean", + "source_sha256": "391e785d8a621b83e1b4e4b4f810109bb52e718debd0b7c25a92282b75a1341c", + "object_path": "lib/lean/Lean/Meta/Eqns.olean", + "object_sha256": "a7c775935894692bd601920da452ac3704a848cb01956749b66ad1a3ba0e0205", + "object_bytes": 744464, + "imports": [ + "Lean.ReservedNameAction", + "Lean.AddDecl", + "Lean.Meta.Basic", + "Lean.Meta.AppBuilder", + "Lean.Meta.Match.MatcherInfo" + ] + }, + { + "module": "Lean.DocString", + "root": "lean", + "source_path": "src/lean/Lean/DocString.lean", + "source_sha256": "34cce7e12b1efae4434fde58199bc6393232505a780a4ac684424c98053e8be1", + "object_path": "lib/lean/Lean/DocString.olean", + "object_sha256": "437c079f963668093dffd0dd269174ec7bcd52a0470715dc89312dea46fdac65", + "object_bytes": 51240, + "imports": [ + "Lean.DocString.Extension", + "Lean.DocString.Links", + "Lean.Parser.Tactic.Doc", + "Lean.Parser.Term.Doc" + ] + }, + { + "module": "Lean.Meta.Tactic.Simp.SimpTheorems", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Simp/SimpTheorems.lean", + "source_sha256": "6b5606e2f8fbcf3f2fb1844d771135b695db5b82168ef1aea7a672210e45e407", + "object_path": "lib/lean/Lean/Meta/Tactic/Simp/SimpTheorems.olean", + "object_sha256": "146200426759262196331759d424428c44330e469c4775a7a1aef2199f8edaca", + "object_bytes": 2045728, + "imports": [ + "Lean.ScopedEnvExtension", + "Lean.Util.Recognizers", + "Lean.Meta.DiscrTree", + "Lean.Meta.AppBuilder", + "Lean.Meta.Eqns", + "Lean.Meta.Tactic.AuxLemma", + "Lean.DocString", + "Lean.PrettyPrinter" + ] + }, + { + "module": "Lean.Meta.Tactic.Simp.SimpCongrTheorems", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Simp/SimpCongrTheorems.lean", + "source_sha256": "73735f1b202cc22c09f568957d03a3e4233046e174208fd9521a71bedbb360a5", + "object_path": "lib/lean/Lean/Meta/Tactic/Simp/SimpCongrTheorems.olean", + "object_sha256": "180b22a6c63a0e51a5e454fd8b652708e6161a7515f70a8470f273a620a3d10f", + "object_bytes": 1030656, + "imports": [ + "Lean.ScopedEnvExtension", + "Lean.Util.Recognizers", + "Lean.Util.CollectMVars", + "Lean.Meta.Basic" + ] + }, + { + "module": "Lean.Meta.Tactic.Simp.Types", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Simp/Types.lean", + "source_sha256": "a3788f952f1aba36d8cc04f3bddebfde64e194675f050747baa46552a59c8248", + "object_path": "lib/lean/Lean/Meta/Tactic/Simp/Types.olean", + "object_sha256": "5978e3c8ec745e4da74de0d29bbd87f907876d18bac70bf11a775f79b517ea1c", + "object_bytes": 2598696, + "imports": [ + "Lean.Meta.AppBuilder", + "Lean.Meta.CongrTheorems", + "Lean.Meta.Eqns", + "Lean.Meta.Tactic.Replace", + "Lean.Meta.Tactic.Simp.SimpTheorems", + "Lean.Meta.Tactic.Simp.SimpCongrTheorems" + ] + }, + { + "module": "Lean.Util.SortExprs", + "root": "lean", + "source_path": "src/lean/Lean/Util/SortExprs.lean", + "source_sha256": "ac756fb0971ef8ff8aa38642ecd831565a9bbc37c4e1c4e1f7ca70c70eeb9194", + "object_path": "lib/lean/Lean/Util/SortExprs.olean", + "object_sha256": "13d9a7779db0192f7ed08c64dd83fa0f19a64b76eb0feed0db68954a7008ad04", + "object_bytes": 174000, + "imports": [ + "Lean.Expr" + ] + }, + { + "module": "Lean.HeadIndex", + "root": "lean", + "source_path": "src/lean/Lean/HeadIndex.lean", + "source_sha256": "aca3d5d76e09a7844f0d30a9422aba5a2c918bbe56a911e0f2736d50c6d6f408", + "object_path": "lib/lean/Lean/HeadIndex.olean", + "object_sha256": "97cf032797bbbeb36e19880847b7d93cb2acc4364d753c077fc611a3c5f778e5", + "object_bytes": 309152, + "imports": [ + "Lean.Expr" + ] + }, + { + "module": "Lean.Meta.KExprMap", + "root": "lean", + "source_path": "src/lean/Lean/Meta/KExprMap.lean", + "source_sha256": "a17c89df31717a1569a83b0b547b9f21ce85fab7b9a335c73b10f629e198c000", + "object_path": "lib/lean/Lean/Meta/KExprMap.olean", + "object_sha256": "c1e1e0faa51e40af0cdd091d9325b46774b4ee1e7939414d80917c3f7f3c2e34", + "object_bytes": 241152, + "imports": [ + "Lean.Data.AssocList", + "Lean.HeadIndex", + "Lean.Meta.Basic" + ] + }, + { + "module": "Lean.Meta.Tactic.Simp.Arith.Nat.Basic", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Simp/Arith/Nat/Basic.lean", + "source_sha256": "628f7dad2048588894ffd828fa07c3708bebdf22304c9d0a5d4815c4a6e4e17f", + "object_path": "lib/lean/Lean/Meta/Tactic/Simp/Arith/Nat/Basic.olean", + "object_sha256": "85f570beb0d3d813b416729cc307d49fffc94ad0fa7e0d746ca82396541be20b", + "object_bytes": 719136, + "imports": [ + "Lean.Util.SortExprs", + "Lean.Meta.Check", + "Lean.Meta.Offset", + "Lean.Meta.AppBuilder", + "Lean.Meta.KExprMap", + "Lean.Data.RArray" + ] + }, + { + "module": "Lean.Meta.Tactic.Simp.Arith.Util", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Simp/Arith/Util.lean", + "source_sha256": "2aaf81a1bd09495b9c1d6f5b8a8929f8839816743d12cbc474b4491f86f7e02f", + "object_path": "lib/lean/Lean/Meta/Tactic/Simp/Arith/Util.olean", + "object_sha256": "7b5ec79ae063e85a1706d5727898ca9aa93d38be687e14b1c0dc25ed9b57b0d8", + "object_bytes": 248704, + "imports": [ + "Lean.Meta.Basic", + "Lean.Expr" + ] + }, + { + "module": "Lean.Meta.Tactic.Simp.Arith.Nat.Simp", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Simp/Arith/Nat/Simp.lean", + "source_sha256": "b9158d3b8d062a42a55408d194ab9ddc100e6592a5fb252d9c14791086e2a2d2", + "object_path": "lib/lean/Lean/Meta/Tactic/Simp/Arith/Nat/Simp.olean", + "object_sha256": "6d2c3a07063f27f34367bf9a935f50d894bbfc9a9bc2772bc83a421b89aea1cb", + "object_bytes": 242656, + "imports": [ + "Lean.Meta.Tactic.Simp.Arith.Util", + "Lean.Meta.Tactic.Simp.Arith.Nat.Basic" + ] + }, + { + "module": "Lean.Meta.Tactic.Simp.Arith.Nat", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Simp/Arith/Nat.lean", + "source_sha256": "bdc6d39ae399b4033f581a17ee0fddc6fc26ba02bf29f01bf939eeba7dd6bb69", + "object_path": "lib/lean/Lean/Meta/Tactic/Simp/Arith/Nat.olean", + "object_sha256": "35fdfcc34873900e59144452c17b447da3e54f550ee9c2b2c2896cfb0e0a16f2", + "object_bytes": 18088, + "imports": [ + "Lean.Meta.Tactic.Simp.Arith.Nat.Basic", + "Lean.Meta.Tactic.Simp.Arith.Nat.Simp" + ] + }, + { + "module": "Lean.Meta.IntInstTesters", + "root": "lean", + "source_path": "src/lean/Lean/Meta/IntInstTesters.lean", + "source_sha256": "1c4a1194561494066925654d1c8c3b941339716827fd8a403650eada007ecdae", + "object_path": "lib/lean/Lean/Meta/IntInstTesters.olean", + "object_sha256": "30f61f43a00b1d6a247f9a61c644205036300ad0aa2b4e1e713289e22e3bb8e7", + "object_bytes": 145968, + "imports": [ + "Lean.Meta.Basic" + ] + }, + { + "module": "Lean.Meta.Tactic.Simp.Arith.Int.Basic", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Simp/Arith/Int/Basic.lean", + "source_sha256": "30f81ab6a22a317c128f86f2ff6adfe6c968764de470354abd6125f73587dca4", + "object_path": "lib/lean/Lean/Meta/Tactic/Simp/Arith/Int/Basic.olean", + "object_sha256": "09e9fa70efc9bbc4fa582572f96070c69483fae52a09c379ec7843f8f9077638", + "object_bytes": 996776, + "imports": [ + "Init.Data.Int.Linear", + "Lean.Util.SortExprs", + "Lean.Meta.Check", + "Lean.Meta.Offset", + "Lean.Meta.IntInstTesters", + "Lean.Meta.AppBuilder", + "Lean.Meta.KExprMap", + "Lean.Data.RArray" + ] + }, + { + "module": "Lean.Meta.Tactic.Simp.Arith.Int.Simp", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Simp/Arith/Int/Simp.lean", + "source_sha256": "4f616a21dca904209190393e7a462b67c15db4ddb3f0eeac655b03ac93d4d2fd", + "object_path": "lib/lean/Lean/Meta/Tactic/Simp/Arith/Int/Simp.olean", + "object_sha256": "377b805ca95b7eb3a8364143c38cc6b688054fc5e7391fb59c4a1f4d3dc89866", + "object_bytes": 1066008, + "imports": [ + "Lean.Meta.Tactic.Simp.Arith.Util", + "Lean.Meta.Tactic.Simp.Arith.Int.Basic" + ] + }, + { + "module": "Lean.Meta.Tactic.Simp.Arith.Int", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Simp/Arith/Int.lean", + "source_sha256": "77dc9160a8611765842305925c01387f2e04135e5a71fb3da8e5b9ee63eabad9", + "object_path": "lib/lean/Lean/Meta/Tactic/Simp/Arith/Int.olean", + "object_sha256": "24d55113d283efbb8a3f1160de4b83ae75b76e922f5dd1f674f32f453c26fe84", + "object_bytes": 18088, + "imports": [ + "Lean.Meta.Tactic.Simp.Arith.Int.Basic", + "Lean.Meta.Tactic.Simp.Arith.Int.Simp" + ] + }, + { + "module": "Lean.Meta.Tactic.Simp.Arith", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Simp/Arith.lean", + "source_sha256": "b790e7f70d2287441013b139148dc8aabbac6369940ca4e75aadffd4d242de0d", + "object_path": "lib/lean/Lean/Meta/Tactic/Simp/Arith.olean", + "object_sha256": "ca585958629ca2c68cf5d5a5cb0dc102d4cdecfb759a0239efd0c722842be183", + "object_bytes": 29896, + "imports": [ + "Lean.Meta.Tactic.Simp.Arith.Nat", + "Lean.Meta.Tactic.Simp.Arith.Int" + ] + }, + { + "module": "Lean.Meta.Tactic.Simp.Simproc", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Simp/Simproc.lean", + "source_sha256": "71e85443dc7dba92ef10d701deae4d2158203924e9a9d88c7cad540768b84362", + "object_path": "lib/lean/Lean/Meta/Tactic/Simp/Simproc.olean", + "object_sha256": "1799b2f7af387f6a4103ce544dfc99b94258f3ce164b01efbe2b92e1fde6f4a5", + "object_bytes": 2009960, + "imports": [ + "Lean.ScopedEnvExtension", + "Lean.Compiler.InitAttr", + "Lean.Meta.DiscrTree", + "Lean.Meta.Tactic.Simp.Types" + ] + }, + { + "module": "Lean.Meta.Tactic.Simp.Attr", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Simp/Attr.lean", + "source_sha256": "1d064fa3f3f336b955e45eda897c8acef978211a673cafeaf87f3ee6b05d3aa5", + "object_path": "lib/lean/Lean/Meta/Tactic/Simp/Attr.olean", + "object_sha256": "a920424988fbc633444dd219eedda1ed2711fc5f867b4f6bcf41baf9e82a2dbc", + "object_bytes": 456760, + "imports": [ + "Lean.Meta.Tactic.Simp.Types", + "Lean.Meta.Tactic.Simp.SimpTheorems", + "Lean.Meta.Tactic.Simp.Simproc" + ] + }, + { + "module": "Lean.Meta.BinderNameHint", + "root": "lean", + "source_path": "src/lean/Lean/Meta/BinderNameHint.lean", + "source_sha256": "c6e0557f4bfd0f3c3c09722ffc67e90990bf2b02f7cc4b6f846c6148b81ef2dd", + "object_path": "lib/lean/Lean/Meta/BinderNameHint.olean", + "object_sha256": "24c9649686763e64ec477053bc4e8409cb8b25ba51116e20d648b2d0a6621173", + "object_bytes": 701408, + "imports": [ + "Lean.Util.FindExpr", + "Lean.Meta.Basic", + "Init.BinderNameHint" + ] + }, + { + "module": "Lean.Meta.Tactic.Simp.Rewrite", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Simp/Rewrite.lean", + "source_sha256": "f7fe2234b4a00b09adc0f125f519b349b020614302331806a8fa3b7c9625442b", + "object_path": "lib/lean/Lean/Meta/Tactic/Simp/Rewrite.olean", + "object_sha256": "c5039d0077257ac97d05669f0817ca7dbd8d73775cd0c7c542ac5f3c41f25d14", + "object_bytes": 2581736, + "imports": [ + "Lean.Meta.ACLt", + "Lean.Meta.Match.MatchEqsExt", + "Lean.Meta.AppBuilder", + "Lean.Meta.SynthInstance", + "Lean.Meta.Tactic.Util", + "Lean.Meta.Tactic.UnifyEq", + "Lean.Meta.Tactic.Simp.Types", + "Lean.Meta.Tactic.Simp.Arith", + "Lean.Meta.Tactic.Simp.Simproc", + "Lean.Meta.Tactic.Simp.Attr", + "Lean.Meta.BinderNameHint" + ] + }, + { + "module": "Lean.Meta.Tactic.Simp.Diagnostics", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Simp/Diagnostics.lean", + "source_sha256": "fbcc2e1f084812b374e38857fe9051bb21444371df4eb13d2df705110c31c750", + "object_path": "lib/lean/Lean/Meta/Tactic/Simp/Diagnostics.olean", + "object_sha256": "11af0f34a904a356691799262cbdb2525833e6e747fa4d4b495704bc9ebedcfd", + "object_bytes": 343872, + "imports": [ + "Lean.Meta.Diagnostics", + "Lean.Meta.Tactic.Simp.Types" + ] + }, + { + "module": "Lean.Meta.Match.Value", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Match/Value.lean", + "source_sha256": "d07bc985d5efd57b892180800779330ae76c9f0f8ded97d73f15630c17089048", + "object_path": "lib/lean/Lean/Meta/Match/Value.olean", + "object_sha256": "614cd91700ddcd30f2d0dde3fe9cc57a89990eabb5e738c7a1bd2a2b23bdf71a", + "object_bytes": 89888, + "imports": [ + "Lean.Meta.LitValues", + "Lean.Expr" + ] + }, + { + "module": "Lean.Meta.Tactic.Simp.Main", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Simp/Main.lean", + "source_sha256": "811848d187137133dde00f062d6d529eb8dba8bde6950539f65dc39cb222e2b1", + "object_path": "lib/lean/Lean/Meta/Tactic/Simp/Main.olean", + "object_sha256": "3eef2f97c27164e868e46a454e87e19a72c1eef0d4904ca527d071ac77cdee48", + "object_bytes": 3986272, + "imports": [ + "Lean.Meta.Transform", + "Lean.Meta.Tactic.Replace", + "Lean.Meta.Tactic.UnifyEq", + "Lean.Meta.Tactic.Simp.Rewrite", + "Lean.Meta.Tactic.Simp.Diagnostics", + "Lean.Meta.Match.Value" + ] + }, + { + "module": "Lean.Meta.Tactic.Acyclic", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Acyclic.lean", + "source_sha256": "4a251ea771c3384e04b22b04c0f3ed63e5a50ea2e7afc61e0b75ce8e75465546", + "object_path": "lib/lean/Lean/Meta/Tactic/Acyclic.olean", + "object_sha256": "9e4813c287db66e3b26a3330ceb1bfada223686cb7bf9ebb2363955649e2d1c8", + "object_bytes": 306432, + "imports": [ + "Lean.Meta.MatchUtil", + "Lean.Meta.Tactic.Simp.Main" + ] + }, + { + "module": "Lean.Meta.Tactic.Cases", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Cases.lean", + "source_sha256": "06fd0ffabfe59f67f6077a52602241d85015f93075251a6ec74c79f3552245c9", + "object_path": "lib/lean/Lean/Meta/Tactic/Cases.olean", + "object_sha256": "de2922389fdc70c4e72bee5e06ded9d5efb6c7c0f04237d8e591bbba1b5623b8", + "object_bytes": 1510208, + "imports": [ + "Lean.Meta.AppBuilder", + "Lean.Meta.Tactic.Induction", + "Lean.Meta.Tactic.Injection", + "Lean.Meta.Tactic.Assert", + "Lean.Meta.Tactic.Subst", + "Lean.Meta.Tactic.Acyclic", + "Lean.Meta.Tactic.UnifyEq" + ] + }, + { + "module": "Lean.Meta.Tactic.Assumption", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Assumption.lean", + "source_sha256": "cebff1c60a9b6be9768b9747743211fb08311d4e36106cca97701fa56efac261", + "object_path": "lib/lean/Lean/Meta/Tactic/Assumption.olean", + "object_sha256": "c14b45d320deec28c0a0a965b8dfc4c108342d949d3f0489c9c6655ae16d9875", + "object_bytes": 111088, + "imports": [ + "Lean.Meta.Tactic.Util" + ] + }, + { + "module": "Lean.Meta.Tactic.Apply", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Apply.lean", + "source_sha256": "7aa54e370289e8aca7159f92d9bd607b01bee058bf801310d66805827b4af53c", + "object_path": "lib/lean/Lean/Meta/Tactic/Apply.olean", + "object_sha256": "c85e6a23f283afec65141964b5592e15f8b2d19c2206ff1e5b8932fe3e371320", + "object_bytes": 1063648, + "imports": [ + "Lean.Util.FindMVar", + "Lean.Meta.SynthInstance", + "Lean.Meta.CollectMVars", + "Lean.Meta.Tactic.Util", + "Lean.PrettyPrinter" + ] + }, + { + "module": "Lean.Meta.Tactic.Contradiction", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Contradiction.lean", + "source_sha256": "7f7f800fb71fcec7fa7d31cd88afea2900d82e703e26e02d915a4e5962157897", + "object_path": "lib/lean/Lean/Meta/Tactic/Contradiction.olean", + "object_sha256": "aa9cb1b20943cd85b4072dcdf3ddf9dd2b2b42d93b5fa34c0c6b578e1a9981fc", + "object_bytes": 957296, + "imports": [ + "Lean.Meta.MatchUtil", + "Lean.Meta.Tactic.Assumption", + "Lean.Meta.Tactic.Cases", + "Lean.Meta.Tactic.Apply" + ] + }, + { + "module": "Lean.Meta.KAbstract", + "root": "lean", + "source_path": "src/lean/Lean/Meta/KAbstract.lean", + "source_sha256": "1952cdea4fab5c534cd16fd31aab52fc1be86eaf7410f845f9ce488b218d7a2b", + "object_path": "lib/lean/Lean/Meta/KAbstract.olean", + "object_sha256": "2c4a7af14e931f0281b5e1ca2d6a629e71ebf99fd4ce20b3356590873eb5056f", + "object_bytes": 515056, + "imports": [ + "Lean.HeadIndex", + "Lean.Meta.Basic" + ] + }, + { + "module": "Lean.Meta.GeneralizeTelescope", + "root": "lean", + "source_path": "src/lean/Lean/Meta/GeneralizeTelescope.lean", + "source_sha256": "3cde294b26a18a9fd3b582b1abf26b6885be76250328ea9dc096ea020e206435", + "object_path": "lib/lean/Lean/Meta/GeneralizeTelescope.olean", + "object_sha256": "b0d3e177d5dd3f89197b02bf970d7caccd4b860d3d75f3e1b84f8f75f1cf4fb5", + "object_bytes": 325952, + "imports": [ + "Lean.Meta.KAbstract", + "Lean.Meta.Check" + ] + }, + { + "module": "Lean.Util.CollectFVars", + "root": "lean", + "source_path": "src/lean/Lean/Util/CollectFVars.lean", + "source_sha256": "978178b9b9b24bfb24e707803f9fcadd8a698d254fac440d6719b9f677f6cb2d", + "object_path": "lib/lean/Lean/Util/CollectFVars.olean", + "object_sha256": "3a8b2c1e4dc30355bad4c8fe02098b07ab34b7c801e488ff0c08680dcac7c770", + "object_bytes": 173960, + "imports": [ + "Lean.Expr", + "Lean.LocalContext" + ] + }, + { + "module": "Lean.Meta.CollectFVars", + "root": "lean", + "source_path": "src/lean/Lean/Meta/CollectFVars.lean", + "source_sha256": "9f1f15487f5c45df3d9314940c11053c1291010172d33413932f0148392db239", + "object_path": "lib/lean/Lean/Meta/CollectFVars.olean", + "object_sha256": "24648989bb55f190f121a748cd6778e7fd6fe79152afa0d7142a39aae0b0d328", + "object_bytes": 201944, + "imports": [ + "Lean.Util.CollectFVars", + "Lean.Meta.Basic" + ] + }, + { + "module": "Lean.Meta.Match.CaseValues", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Match/CaseValues.lean", + "source_sha256": "d936859a04a4ec234c0ccd9bc7c71d4ef28abfcdfe21832fd7577df2f38e3618", + "object_path": "lib/lean/Lean/Meta/Match/CaseValues.olean", + "object_sha256": "2db9e230328ce9e3672d85d83fe636f2175b596ff7807ac18f6dad6300fc1038", + "object_bytes": 385152, + "imports": [ + "Lean.Meta.Tactic.Subst", + "Lean.Meta.Tactic.Clear", + "Lean.Meta.Match.Value" + ] + }, + { + "module": "Lean.Meta.Match.CaseArraySizes", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Match/CaseArraySizes.lean", + "source_sha256": "fa16131913195db0570dc84d5ffcc280cccc10b1541e1197df177568d17e1559", + "object_path": "lib/lean/Lean/Meta/Match/CaseArraySizes.olean", + "object_sha256": "d57d86b82596582fd0cf7083bba1f46a1ab69f2a823da1fef7c38eae7bc3fada", + "object_bytes": 304712, + "imports": [ + "Lean.Meta.Tactic.Assert", + "Lean.Meta.Match.CaseValues" + ] + }, + { + "module": "Lean.Meta.Match.Basic", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Match/Basic.lean", + "source_sha256": "e06f7ba1a11b00d813ef91b211fa59e9be6b03d1ef51feebc087ef798b03d4e9", + "object_path": "lib/lean/Lean/Meta/Match/Basic.olean", + "object_sha256": "7d8adef9558f42e0848af10a4a9942460900d01155359f5933422239f1895f94", + "object_bytes": 1198160, + "imports": [ + "Lean.Meta.Check", + "Lean.Meta.CollectFVars", + "Lean.Meta.Match.MatcherInfo", + "Lean.Meta.Match.CaseArraySizes" + ] + }, + { + "module": "Lean.Meta.Match.MatcherApp.Basic", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Match/MatcherApp/Basic.lean", + "source_sha256": "c54f093c2e0ccacba9d9d6f8f633ced7325fd307d1a38bdf1f893eb59470dc3d", + "object_path": "lib/lean/Lean/Meta/Match/MatcherApp/Basic.olean", + "object_sha256": "9d379fe46e5db2902e831b442948a2f0d59065f09f35caecb2e70ad16b967325", + "object_bytes": 347000, + "imports": [ + "Lean.Meta.Match.MatcherInfo" + ] + }, + { + "module": "Lean.Meta.Match.MVarRenaming", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Match/MVarRenaming.lean", + "source_sha256": "0b21ac2cff2bece3bf3a32e1f04b356e65a05cbbe4243590f5237708c4229385", + "object_path": "lib/lean/Lean/Meta/Match/MVarRenaming.olean", + "object_sha256": "d752af1d0c8a1fa66c53bd28de20370ba2eef1afd263b0522ef66a5954e5aa6e", + "object_bytes": 102256, + "imports": [ + "Lean.Util.ReplaceExpr" + ] + }, + { + "module": "Lean.Meta.Match.Match", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Match/Match.lean", + "source_sha256": "a16c7a137b4b2d3a1612801415e4c589693bee626df4cdecf83143ff683941e8", + "object_path": "lib/lean/Lean/Meta/Match/Match.olean", + "object_sha256": "3257c5e39260d7991623140ce36a561cd2783041a15478aa5790e607e2a7cc89", + "object_bytes": 3745832, + "imports": [ + "Lean.Meta.LitValues", + "Lean.Meta.Check", + "Lean.Meta.Closure", + "Lean.Meta.CtorRecognizer", + "Lean.Meta.Tactic.Cases", + "Lean.Meta.Tactic.Contradiction", + "Lean.Meta.GeneralizeTelescope", + "Lean.Meta.Match.Basic", + "Lean.Meta.Match.MatcherApp.Basic", + "Lean.Meta.Match.MVarRenaming" + ] + }, + { + "module": "Lean.Meta.GeneralizeVars", + "root": "lean", + "source_path": "src/lean/Lean/Meta/GeneralizeVars.lean", + "source_sha256": "32e91f609eee25d96bcf06abfdffea141348adc01772f6955c7c8c04a4cccc65", + "object_path": "lib/lean/Lean/Meta/GeneralizeVars.olean", + "object_sha256": "307e7194bf9ee398fc410ee9c0c8f4fcd11ec57e18a2bd33b02a0d495632cfe1", + "object_bytes": 701112, + "imports": [ + "Lean.Meta.Basic", + "Lean.Util.CollectFVars" + ] + }, + { + "module": "Lean.Meta.ForEachExpr", + "root": "lean", + "source_path": "src/lean/Lean/Meta/ForEachExpr.lean", + "source_sha256": "bf406be30f55af36c5f93fd35d42e166280b184a3781acd43d0afd88dbbe03b7", + "object_path": "lib/lean/Lean/Meta/ForEachExpr.olean", + "object_sha256": "b1d37872d5bf84daa4552142a7f4c08d7a31a19d3f00f30ea3f55fac937e9aaf", + "object_bytes": 700800, + "imports": [ + "Lean.Expr", + "Lean.Util.MonadCache", + "Lean.Meta.Basic" + ] + }, + { + "module": "Lean.Elab.Arg", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Arg.lean", + "source_sha256": "217475a3312e7f418e8bdfc7dc88389b5eec583a3282609e1ff25b1a5863397c", + "object_path": "lib/lean/Lean/Elab/Arg.olean", + "object_sha256": "979c0321564553c200c48d31f8fbeb63956e448efe1cdf1ab2e6089abdb89d85", + "object_bytes": 225944, + "imports": [ + "Lean.Elab.Term" + ] + }, + { + "module": "Lean.Elab.MatchAltView", + "root": "lean", + "source_path": "src/lean/Lean/Elab/MatchAltView.lean", + "source_sha256": "b33401a608a835a283390e1bdb984d3adceba6e08ee1e46f75395a7e7b58aa0a", + "object_path": "lib/lean/Lean/Elab/MatchAltView.olean", + "object_sha256": "61eb899aeb2be7387cdc4aecf4635451c5deb1990e5c1f3885f892abc88fe0ae", + "object_bytes": 65864, + "imports": [ + "Lean.Elab.Term" + ] + }, + { + "module": "Lean.Elab.PatternVar", + "root": "lean", + "source_path": "src/lean/Lean/Elab/PatternVar.lean", + "source_sha256": "1d682e7b9ec0f0d2c2f030a3063cac66496b5eacd33903ba535a2917144dc19b", + "object_path": "lib/lean/Lean/Elab/PatternVar.olean", + "object_sha256": "f02d07ab9d66466016209f44f2db161422eb9fbe151d10117d7c9b0bbc85dea2", + "object_bytes": 1847016, + "imports": [ + "Lean.Meta.Match.MatchPatternAttr", + "Lean.Elab.Arg", + "Lean.Elab.MatchAltView" + ] + }, + { + "module": "Lean.Elab.Match", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Match.lean", + "source_sha256": "775f78b30932b3dd3a9a6d8bb0d8962b31eb46fe2f8b69c71842868cb0856aa1", + "object_path": "lib/lean/Lean/Elab/Match.olean", + "object_sha256": "a7581e696ad8e7c2c681a383900016b93a114299fd1ea3a1fafb1183a0b9a1e5", + "object_bytes": 5082624, + "imports": [ + "Lean.Util.ForEachExprWhere", + "Lean.Meta.CtorRecognizer", + "Lean.Meta.Match.Match", + "Lean.Meta.GeneralizeVars", + "Lean.Meta.ForEachExpr", + "Lean.Elab.BindersUtil", + "Lean.Elab.PatternVar", + "Lean.Elab.Quotation.Precheck", + "Lean.Elab.SyntheticMVars" + ] + }, + { + "module": "Lean.Elab.Binders", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Binders.lean", + "source_sha256": "e445a16ada7265d4bb82dd224c228da8dbeaa3eef6d8c72876cf820eccd33796", + "object_path": "lib/lean/Lean/Elab/Binders.olean", + "object_sha256": "15756ac54cfa07aa7238633ffc2f5fc4dd70e16b41131aac589b8017f90a8a6a", + "object_bytes": 2730056, + "imports": [ + "Lean.Elab.Quotation.Precheck", + "Lean.Elab.Term", + "Lean.Elab.BindersUtil", + "Lean.Elab.SyntheticMVars", + "Lean.Elab.PreDefinition.TerminationHint", + "Lean.Elab.Match" + ] + }, + { + "module": "Lean.Elab.SetOption", + "root": "lean", + "source_path": "src/lean/Lean/Elab/SetOption.lean", + "source_sha256": "16bf818f2efb93f9d067107fcfcc8af5b643ad26c7ff3aae8a109ac67317dfc1", + "object_path": "lib/lean/Lean/Elab/SetOption.olean", + "object_sha256": "1480e146fbc065bafe4f9aab91c910b2b2c79df6d801b060c7f7e65a6fdf97a0", + "object_bytes": 120664, + "imports": [ + "Lean.Log", + "Lean.Elab.InfoTree" + ] + }, + { + "module": "Lean.Elab.Command", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Command.lean", + "source_sha256": "453fa5607c18e9a7cc290c670ce194b236a5966e6b38a41c832f6e52b6ff88de", + "object_path": "lib/lean/Lean/Elab/Command.olean", + "object_sha256": "fbc4ee91e435d54f5709886d75141985feedc888bf3170add8af5657db575aff", + "object_bytes": 3197920, + "imports": [ + "Lean.Meta.Diagnostics", + "Lean.Elab.Binders", + "Lean.Elab.SyntheticMVars", + "Lean.Elab.SetOption", + "Lean.Language.Basic", + "Lean.Meta.ForEachExpr" + ] + }, + { + "module": "Lean.Meta.Tactic.ElimInfo", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/ElimInfo.lean", + "source_sha256": "add30eced85e62f13bbabbe72d0930888bb5ab957363c3aca72c441dd7899083", + "object_path": "lib/lean/Lean/Meta/Tactic/ElimInfo.olean", + "object_sha256": "94b21f0f9809cabd4579fa0f599e9515377ff41252e3fb58197119a72adffcf3", + "object_bytes": 1445624, + "imports": [ + "Lean.Meta.Basic", + "Lean.Meta.Check", + "Lean.ScopedEnvExtension" + ] + }, + { + "module": "Lean.Elab.RecAppSyntax", + "root": "lean", + "source_path": "src/lean/Lean/Elab/RecAppSyntax.lean", + "source_sha256": "a948bc3e89ed8e4c4891c4b878600b2e95befcbc2fee8db73d02a468c6cff8b0", + "object_path": "lib/lean/Lean/Elab/RecAppSyntax.olean", + "object_sha256": "4f95e243020edd109c5b37ce064331d2d4bc6bf0fdaecbc84b39694fea8c4e3f", + "object_bytes": 66960, + "imports": [ + "Lean.Expr" + ] + }, + { + "module": "Lean.Elab.App", + "root": "lean", + "source_path": "src/lean/Lean/Elab/App.lean", + "source_sha256": "bbe74d34000c83bbe4a6391bafd3718118a488fc07c10cb5141b969af4e7a997", + "object_path": "lib/lean/Lean/Elab/App.olean", + "object_sha256": "a3a8d513b41151c6fd111ad512112f1aeb3b63de295254aaf3ff5cc75b9ab809", + "object_bytes": 5737768, + "imports": [ + "Lean.Util.FindMVar", + "Lean.Util.CollectFVars", + "Lean.Parser.Term", + "Lean.Meta.KAbstract", + "Lean.Meta.Tactic.ElimInfo", + "Lean.Elab.Term", + "Lean.Elab.Binders", + "Lean.Elab.SyntheticMVars", + "Lean.Elab.Arg", + "Lean.Elab.RecAppSyntax" + ] + }, + { + "module": "Lean.Elab.Syntax", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Syntax.lean", + "source_sha256": "0e48f441a297438fa283e4b60170e8c511ee451af207e694ca032882908e5ede", + "object_path": "lib/lean/Lean/Elab/Syntax.olean", + "object_sha256": "ff88324bca3811fa482c2a861d6f8d3a8a16435da1ee3a19fbb86514ffa12407", + "object_bytes": 2347056, + "imports": [ + "Lean.Elab.Command", + "Lean.Parser.Syntax", + "Lean.Elab.Util" + ] + }, + { + "module": "Lean.Elab.MacroArgUtil", + "root": "lean", + "source_path": "src/lean/Lean/Elab/MacroArgUtil.lean", + "source_sha256": "b36e84419c93cecac207a7e6012e91eb627b15ca2f4a63e1aec039416fad240d", + "object_path": "lib/lean/Lean/Elab/MacroArgUtil.olean", + "object_sha256": "980bf7d3cbf9d47871be4d3277b7f8a6365cfcfeb9c48792185a096f7636299e", + "object_bytes": 1165416, + "imports": [ + "Lean.Elab.Syntax" + ] + }, + { + "module": "Lean.Meta.Tactic.Simp.RegisterCommand", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Simp/RegisterCommand.lean", + "source_sha256": "64f578b8af74b3cf817cd94534865105a8e8b403ef25a899fa9b75b9da21cdf6", + "object_path": "lib/lean/Lean/Meta/Tactic/Simp/RegisterCommand.olean", + "object_sha256": "050a94470c515c025c0c562fcf67a5f332dc6499f9aa7c8731a455bdd1605e15", + "object_bytes": 301072, + "imports": [ + "Lean.Meta.Tactic.Simp.SimpTheorems", + "Lean.Meta.Tactic.Simp.Simproc", + "Lean.Meta.Tactic.Simp.Attr" + ] + }, + { + "module": "Lean.Server.InfoUtils", + "root": "lean", + "source_path": "src/lean/Lean/Server/InfoUtils.lean", + "source_sha256": "79d039c8ca45eae31fbdf68446bfd4874113712099e06cca44d44e7a55108c89", + "object_path": "lib/lean/Lean/Server/InfoUtils.olean", + "object_sha256": "b54efa6ff6034174a75cfe1fbf4addabbc72d1f4c7ed3d9d826c8d9f977dd8d0", + "object_bytes": 1510880, + "imports": [ + "Lean.DocString", + "Lean.PrettyPrinter", + "Lean.Parser.Tactic.Doc" + ] + }, + { + "module": "Lean.Linter.Util", + "root": "lean", + "source_path": "src/lean/Lean/Linter/Util.lean", + "source_sha256": "14bc51d8494ccbcd3d79b3485b5029d57c4d379c6576a0ea456c6b7b309f04a5", + "object_path": "lib/lean/Lean/Linter/Util.olean", + "object_sha256": "15008c756d5e0f86bb8e7a30784a602f86f75ec04eba9dc067f9d39f25df3e56", + "object_bytes": 159512, + "imports": [ + "Lean.Data.Options", + "Lean.Server.InfoUtils", + "Lean.Linter.Basic" + ] + }, + { + "module": "Lean.Linter.MissingDocs", + "root": "lean", + "source_path": "src/lean/Lean/Linter/MissingDocs.lean", + "source_sha256": "a9ffaa65b1e4b3b3452384d7c27ee2949b596d1e297f17f6af69545e28870b86", + "object_path": "lib/lean/Lean/Linter/MissingDocs.olean", + "object_sha256": "b7a1b247817af800d8fe63c48a00fe5238edc9c719a2e77bc4481c5d1f886be6", + "object_bytes": 926768, + "imports": [ + "Lean.Parser.Syntax", + "Lean.Meta.Tactic.Simp.RegisterCommand", + "Lean.Elab.Command", + "Lean.Elab.SetOption", + "Lean.Linter.Util" + ] + }, + { + "module": "Lean.Elab.BinderPredicates", + "root": "lean", + "source_path": "src/lean/Lean/Elab/BinderPredicates.lean", + "source_sha256": "5ec5b2733398713edeb9541960216c70e3f73a3438efa63b4fa4678ad19d0836", + "object_path": "lib/lean/Lean/Elab/BinderPredicates.olean", + "object_sha256": "55e66cbda543e61a09077a94311e0fd581cbe7dfe874773eb154f4052204a862", + "object_bytes": 366376, + "imports": [ + "Init.BinderPredicates", + "Lean.Parser.Syntax", + "Lean.Elab.MacroArgUtil", + "Lean.Linter.MissingDocs" + ] + }, + { + "module": "Lean.Elab.LetRec", + "root": "lean", + "source_path": "src/lean/Lean/Elab/LetRec.lean", + "source_sha256": "68fe5ebcb7149f522d65a70b3de2cdaff3c38550f8bec7e66bd4129eccf6ba6e", + "object_path": "lib/lean/Lean/Elab/LetRec.olean", + "object_sha256": "1ffe49b9feeb09b63de2a75d7d4dfa406876c32127642638e8a2284b718bd70b", + "object_bytes": 932856, + "imports": [ + "Lean.Elab.Attributes", + "Lean.Elab.Binders", + "Lean.Elab.DeclModifiers", + "Lean.Elab.SyntheticMVars", + "Lean.Elab.DeclarationRange" + ] + }, + { + "module": "Lean.Language.Util", + "root": "lean", + "source_path": "src/lean/Lean/Language/Util.lean", + "source_sha256": "a8bbe979c11a5f85fce335ac2fc45ca531f9fefa49f6e30668a66fd87178aebe", + "object_path": "lib/lean/Lean/Language/Util.olean", + "object_sha256": "f5b65a629a0474896978e6001ac3df2e5c5f6cf8998333a53657965f643038a2", + "object_bytes": 259824, + "imports": [ + "Lean.Language.Basic", + "Lean.CoreM", + "Lean.Elab.InfoTree" + ] + }, + { + "module": "Lean.Language.Lean.Types", + "root": "lean", + "source_path": "src/lean/Lean/Language/Lean/Types.lean", + "source_sha256": "cb90b002d1721306895f9c83590fe385d3d7fdef400b1bacda3bb21ee348c4ef", + "object_path": "lib/lean/Lean/Language/Lean/Types.olean", + "object_sha256": "5d3f80a04d15883590b7fddb1ddd8ff1f08c0bc06c28796d39ea56f4480ddf42", + "object_bytes": 360840, + "imports": [ + "Lean.Language.Basic", + "Lean.Elab.Command" + ] + }, + { + "module": "Lean.Language.Lean", + "root": "lean", + "source_path": "src/lean/Lean/Language/Lean.lean", + "source_sha256": "68cee1f59c69ca490e0ffa908f84fb2f38d8a7ecf30036fc75438ba21e2dca45", + "object_path": "lib/lean/Lean/Language/Lean.olean", + "object_sha256": "1f45e0ebfc916960604405fd7361519d23d818323bb2b736789d20ea3e407645", + "object_bytes": 1560936, + "imports": [ + "Lean.Language.Basic", + "Lean.Language.Util", + "Lean.Language.Lean.Types", + "Lean.Parser.Module", + "Lean.Elab.Import" + ] + }, + { + "module": "Lean.Server.Utils", + "root": "lean", + "source_path": "src/lean/Lean/Server/Utils.lean", + "source_sha256": "6449c0f16d55998b00c28fc3665102aa82663ab62c917a4b4262722f94900717", + "object_path": "lib/lean/Lean/Server/Utils.olean", + "object_sha256": "4eb8e4de4d90320bd403fa87b1d9b39f8edaeb80ec6329da68d4d588d8e14a7a", + "object_bytes": 316120, + "imports": [ + "Init.System.Uri", + "Lean.Data.Lsp.Communication", + "Lean.Data.Lsp.Diagnostics", + "Lean.Data.Lsp.Extra", + "Lean.Data.Lsp.TextSync", + "Lean.Server.InfoUtils" + ] + }, + { + "module": "Lean.Server.References", + "root": "lean", + "source_path": "src/lean/Lean/Server/References.lean", + "source_sha256": "b7886651813d6ea3851d9ab13d0dd774102035e4f3ac1ea17e93ea658bd2de51", + "object_path": "lib/lean/Lean/Server/References.olean", + "object_sha256": "fbf602732f349b3df6a5374d84703185a95e43e0a2b5b22c0933a0f4c22eca89", + "object_bytes": 2270464, + "imports": [ + "Lean.Data.Lsp.Internal", + "Lean.Server.Utils", + "Std.Data.TreeMap" + ] + }, + { + "module": "Lean.Util.Profiler", + "root": "lean", + "source_path": "src/lean/Lean/Util/Profiler.lean", + "source_sha256": "c1ed5dff890ecee241d5b25b274fae898152efe26aa6928bbcdf9431462bfe89", + "object_path": "lib/lean/Lean/Util/Profiler.olean", + "object_sha256": "02d6e6e5bd2b6c7a88a92f29ad453ba6449758215710bba1694200d978752f7e", + "object_bytes": 4349720, + "imports": [ + "Lean.Util.Trace" + ] + }, + { + "module": "Lean.Elab.Frontend", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Frontend.lean", + "source_sha256": "d53de0aa2ac556c3b13cdedadd6ef57f21a71aa4bb4d01009751077a0e598ca7", + "object_path": "lib/lean/Lean/Elab/Frontend.olean", + "object_sha256": "e25a11f1a5b2eb6c8c8847a1789b2f1fcbaf73c14a71095786d99c118168bb61", + "object_bytes": 598568, + "imports": [ + "Lean.Language.Lean", + "Lean.Util.Profile", + "Lean.Server.References", + "Lean.Util.Profiler" + ] + }, + { + "module": "Lean.Meta.Eval", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Eval.lean", + "source_sha256": "dbacf3f6726a7aa148d874a9c9fdc643139f45bbb3a678556bad0406bcf1e5be", + "object_path": "lib/lean/Lean/Meta/Eval.olean", + "object_sha256": "23f1331066c2c48297d5df196640740ede4d7b9f62b827e54dc15f737399fe6e", + "object_bytes": 255664, + "imports": [ + "Lean.AddDecl", + "Lean.Meta.Check", + "Lean.Util.CollectLevelParams" + ] + }, + { + "module": "Lean.Elab.Eval", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Eval.lean", + "source_sha256": "c7f86031470ababa41aee4965731ac327b3627ca59a9879d6f70b72c67abd147", + "object_path": "lib/lean/Lean/Elab/Eval.olean", + "object_sha256": "d3fc5c22f1c1c52f157e9732021a8e47d1876fa01ee11137532abcf9ccd9f7de", + "object_bytes": 107424, + "imports": [ + "Lean.Meta.Eval", + "Lean.Elab.SyntheticMVars" + ] + }, + { + "module": "Lean.Elab.BuiltinNotation", + "root": "lean", + "source_path": "src/lean/Lean/Elab/BuiltinNotation.lean", + "source_sha256": "3c76e74ce069120fb101029c9d531d96b9fe05d46ac8559fbc66753e86cae8d9", + "object_path": "lib/lean/Lean/Elab/BuiltinNotation.olean", + "object_sha256": "bd545d3e2584d9ecf62e8657aad2f45d4690e55639797ee2a6676a704d4a2c8f", + "object_bytes": 2894024, + "imports": [ + "Lean.Compiler.BorrowedAnnotation", + "Lean.Meta.KAbstract", + "Lean.Meta.Closure", + "Lean.Meta.MatchUtil", + "Lean.Compiler.ImplementedByAttr", + "Lean.Elab.SyntheticMVars", + "Lean.Elab.Eval", + "Lean.Elab.Binders" + ] + }, + { + "module": "Lean.Elab.DeclUtil", + "root": "lean", + "source_path": "src/lean/Lean/Elab/DeclUtil.lean", + "source_sha256": "fcad45f7e7856757d99bb17e2b9d32cee8aaadf8b634669afb0042a5e1fada06", + "object_path": "lib/lean/Lean/Elab/DeclUtil.olean", + "object_sha256": "a648ca0a5af789100175aacf30526a59cf2f6ce9ee36a376caaa9321985ec04f", + "object_bytes": 349696, + "imports": [ + "Lean.Meta.Basic", + "Lean.Meta.Check" + ] + }, + { + "module": "Lean.Elab.DeclNameGen", + "root": "lean", + "source_path": "src/lean/Lean/Elab/DeclNameGen.lean", + "source_sha256": "d3320c49bec9c6f7b23c519746257f479eb717d6a4405c075dd25e6b7ffe5037", + "object_path": "lib/lean/Lean/Elab/DeclNameGen.olean", + "object_sha256": "589fd644310b6daef73509d58525174455a3240ebe3437d359fdb8910a84daa5", + "object_bytes": 1248416, + "imports": [ + "Lean.Elab.Command" + ] + }, + { + "module": "Lean.Elab.DefView", + "root": "lean", + "source_path": "src/lean/Lean/Elab/DefView.lean", + "source_sha256": "1c7bc7289bae476f2ffec0bfa354f3d88b5cc6bc28afd1063a6eb0d4eeb6fdb4", + "object_path": "lib/lean/Lean/Elab/DefView.olean", + "object_sha256": "e4cd4902bad001f03bd37946b7f3afded04ad35ed843f506d1a1ee34df5ccf4d", + "object_bytes": 824240, + "imports": [ + "Lean.Elab.Command", + "Lean.Elab.DeclNameGen", + "Lean.Elab.DeclUtil" + ] + }, + { + "module": "Lean.Elab.Deriving.Basic", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Deriving/Basic.lean", + "source_sha256": "9e5bfcf3830d6c5d406d7c137f04d5d0b7fd0493b2e4f0763c7c1153b36b403f", + "object_path": "lib/lean/Lean/Elab/Deriving/Basic.olean", + "object_sha256": "dd030a0baa63f53a204dc6db1f91c83543be0bc75c91214a7b389c263952632e", + "object_bytes": 631896, + "imports": [ + "Lean.Elab.Command", + "Lean.Elab.DeclarationRange" + ] + }, + { + "module": "Lean.Util.SCC", + "root": "lean", + "source_path": "src/lean/Lean/Util/SCC.lean", + "source_sha256": "23a3c1b35049edc7683f6ba35797bec204a58418057c2cba433f2d31cc915610", + "object_path": "lib/lean/Lean/Util/SCC.olean", + "object_sha256": "77260536e9f67f7405a53135533d7ed20f40f90c7650a2dfa6e68f0420172088", + "object_bytes": 369896, + "imports": [ + "Std.Data.HashMap.Basic", + "Init.Data.Option.Coe" + ] + }, + { + "module": "Lean.Util.NumApps", + "root": "lean", + "source_path": "src/lean/Lean/Util/NumApps.lean", + "source_sha256": "daffe219245225b2faad70273ebe8570e090c52aa7625bac413fa9310800ea1c", + "object_path": "lib/lean/Lean/Util/NumApps.olean", + "object_sha256": "2c4ae381136f915384690c607161fc6a8aef725a1f4bbd7eda45329540000359", + "object_bytes": 243656, + "imports": [ + "Lean.Expr", + "Lean.Util.PtrSet" + ] + }, + { + "module": "Lean.Meta.AbstractNestedProofs", + "root": "lean", + "source_path": "src/lean/Lean/Meta/AbstractNestedProofs.lean", + "source_sha256": "599af553e820b0a10be3552d5449ae2a5207c116f2268473cb80f5d30f0ce69f", + "object_path": "lib/lean/Lean/Meta/AbstractNestedProofs.olean", + "object_sha256": "584b11f73468b89f7457701b1ea05d9b6a9b37bef4184bd055b1a9743b649a61", + "object_bytes": 451448, + "imports": [ + "Init.Grind.Util", + "Lean.Meta.Closure", + "Lean.Meta.Transform" + ] + }, + { + "module": "Lean.Elab.PreDefinition.Basic", + "root": "lean", + "source_path": "src/lean/Lean/Elab/PreDefinition/Basic.lean", + "source_sha256": "8778cca402773c96c3f14d76a6ded17d735ef1fce7ab55a9c80b1188b02764a9", + "object_path": "lib/lean/Lean/Elab/PreDefinition/Basic.olean", + "object_sha256": "00ab919cd2e28b5ef41a8e6c384e731e102ec2c9aa63679be10dbfccb1d76ad8", + "object_bytes": 1255256, + "imports": [ + "Init.ShareCommon", + "Lean.Compiler.NoncomputableAttr", + "Lean.Util.CollectLevelParams", + "Lean.Util.NumObjs", + "Lean.Util.NumApps", + "Lean.Meta.AbstractNestedProofs", + "Lean.Meta.ForEachExpr", + "Lean.Meta.Eqns", + "Lean.Elab.RecAppSyntax", + "Lean.Elab.DefView", + "Lean.Elab.PreDefinition.TerminationHint" + ] + }, + { + "module": "Lean.Elab.PreDefinition.TerminationMeasure", + "root": "lean", + "source_path": "src/lean/Lean/Elab/PreDefinition/TerminationMeasure.lean", + "source_sha256": "9fd66354e3fe24eac4e88262fd03dc273a64ed5cbdd52c5bc8dca34ee9241e3e", + "object_path": "lib/lean/Lean/Elab/PreDefinition/TerminationMeasure.olean", + "object_sha256": "eac78cc0c900a9dc73f941690f2462ff766b681c1c07df00b1a402e19b3c4555", + "object_bytes": 483496, + "imports": [ + "Lean.Parser.Term", + "Lean.Elab.Term", + "Lean.Elab.Binders", + "Lean.Elab.SyntheticMVars", + "Lean.Elab.PreDefinition.TerminationHint", + "Lean.PrettyPrinter.Delaborator.Basic" + ] + }, + { + "module": "Lean.Elab.PreDefinition.Mutual", + "root": "lean", + "source_path": "src/lean/Lean/Elab/PreDefinition/Mutual.lean", + "source_sha256": "a17ba99266ca789be3c22f354d85cf6dd06b7e9990bbd287f47d46a6674985d6", + "object_path": "lib/lean/Lean/Elab/PreDefinition/Mutual.olean", + "object_sha256": "49504531e6e51e1c84892c706e441a74f8e259adcb010c9ed8fefabeb0b10ecc", + "object_bytes": 282280, + "imports": [ + "Lean.Elab.PreDefinition.Basic" + ] + }, + { + "module": "Lean.Elab.PreDefinition.Structural.Basic", + "root": "lean", + "source_path": "src/lean/Lean/Elab/PreDefinition/Structural/Basic.lean", + "source_sha256": "93884d0e2254ee948b2601370fa062fce5b8a7ebae53d790b4dceb2c49985a06", + "object_path": "lib/lean/Lean/Elab/PreDefinition/Structural/Basic.olean", + "object_sha256": "a33874048b66487897c6248a16f2e17586ceeb9947e6ecdd182c73b4adc976da", + "object_bytes": 276608, + "imports": [ + "Lean.Meta.Basic", + "Lean.Meta.ForEachExpr" + ] + }, + { + "module": "Lean.Elab.PreDefinition.FixedParams", + "root": "lean", + "source_path": "src/lean/Lean/Elab/PreDefinition/FixedParams.lean", + "source_sha256": "a8bc0e9cbd3859805827652565dc90e40c821c3e6d3a5070512bdcb0715f66e1", + "object_path": "lib/lean/Lean/Elab/PreDefinition/FixedParams.olean", + "object_sha256": "c790215fd06bea16441d09955eec83dafb316bffb882fab40e0713f0279c842c", + "object_bytes": 1832632, + "imports": [ + "Lean.Elab.PreDefinition.Basic" + ] + }, + { + "module": "Lean.Elab.PreDefinition.Structural.IndGroupInfo", + "root": "lean", + "source_path": "src/lean/Lean/Elab/PreDefinition/Structural/IndGroupInfo.lean", + "source_sha256": "544e1e16dab52e4ebade3c078526788f7ba196266b8efb8f59cc8be909a952ca", + "object_path": "lib/lean/Lean/Elab/PreDefinition/Structural/IndGroupInfo.olean", + "object_sha256": "19f6ac1debfa5591767457cbf3b9ac6ad9a79b3fc706af8c6c154d0da3b1e47d", + "object_bytes": 356672, + "imports": [ + "Lean.Meta.InferType" + ] + }, + { + "module": "Lean.Elab.PreDefinition.Structural.RecArgInfo", + "root": "lean", + "source_path": "src/lean/Lean/Elab/PreDefinition/Structural/RecArgInfo.lean", + "source_sha256": "8d60c522ac60c746a3c3345e715e23baa6601a15f469e439a900eae103cf5633", + "object_path": "lib/lean/Lean/Elab/PreDefinition/Structural/RecArgInfo.olean", + "object_sha256": "d4ed20eefa18d3917cc831d1e9d69a05c973b0a74995af6810b21b60b6b11fa0", + "object_bytes": 200544, + "imports": [ + "Lean.Meta.Basic", + "Lean.Meta.ForEachExpr", + "Lean.Elab.PreDefinition.FixedParams", + "Lean.Elab.PreDefinition.Structural.IndGroupInfo" + ] + }, + { + "module": "Lean.Elab.PreDefinition.Structural.FindRecArg", + "root": "lean", + "source_path": "src/lean/Lean/Elab/PreDefinition/Structural/FindRecArg.lean", + "source_sha256": "3cdffd17f1abfc5ecaae802621bdd0e02dcf1acdf5d922e1b05a8f90f3d2e8c5", + "object_path": "lib/lean/Lean/Elab/PreDefinition/Structural/FindRecArg.olean", + "object_sha256": "4e980a433bb93f27ad196581532092900d4c2deeee8b1a211039fbe1b5782c93", + "object_bytes": 1495232, + "imports": [ + "Lean.Elab.PreDefinition.TerminationMeasure", + "Lean.Elab.PreDefinition.FixedParams", + "Lean.Elab.PreDefinition.Structural.Basic", + "Lean.Elab.PreDefinition.Structural.RecArgInfo" + ] + }, + { + "module": "Lean.Elab.PreDefinition.Structural.Preprocess", + "root": "lean", + "source_path": "src/lean/Lean/Elab/PreDefinition/Structural/Preprocess.lean", + "source_sha256": "abe28d89a64a8566c7883139bb0759c42b56494fd586ca23f1a69744d69ad1fb", + "object_path": "lib/lean/Lean/Elab/PreDefinition/Structural/Preprocess.olean", + "object_sha256": "aecbe397a4be40b1832cbcce3f3e518759ba832f506ca908060aca5b1f9f687b", + "object_bytes": 105832, + "imports": [ + "Lean.Meta.Transform", + "Lean.Elab.RecAppSyntax" + ] + }, + { + "module": "Std.Data.HashMap.Raw", + "root": "lean", + "source_path": "src/lean/Std/Data/HashMap/Raw.lean", + "source_sha256": "150c37702fa5aa6f9fc56b30922b74a7e02abb3caf243b66de21b5a54f55de8f", + "object_path": "lib/lean/Std/Data/HashMap/Raw.olean", + "object_sha256": "addfb85da2d428805f7d014ba651d26a4623f8869f7339c4364cdf77321b8e77", + "object_bytes": 1168688, + "imports": [ + "Std.Data.DHashMap.Raw" + ] + }, + { + "module": "Lean.Util.HasConstCache", + "root": "lean", + "source_path": "src/lean/Lean/Util/HasConstCache.lean", + "source_sha256": "529874ed507ae1f16d215a04116e8eea08666409e0638b84f5d9e6f05b9609e4", + "object_path": "lib/lean/Lean/Util/HasConstCache.olean", + "object_sha256": "5b306f6908ed4593a9001122cbbf2fa212e89f02c222cdf0c036bd7984f19979", + "object_bytes": 203160, + "imports": [ + "Lean.Expr", + "Std.Data.HashMap.Raw" + ] + }, + { + "module": "Lean.Meta.PProdN", + "root": "lean", + "source_path": "src/lean/Lean/Meta/PProdN.lean", + "source_sha256": "4eba139d2cbd043ada3ca98b8e1af2de2e98a3f364cce9c2b1fb81a534ef74d2", + "object_path": "lib/lean/Lean/Meta/PProdN.olean", + "object_sha256": "0261d69cde8cbe0de8697543f80e02bda77243d6ab7608c50e335280d0105ed7", + "object_bytes": 382624, + "imports": [ + "Lean.Meta.InferType", + "Lean.Meta.Transform" + ] + }, + { + "module": "Lean.Meta.Reduce", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Reduce.lean", + "source_sha256": "d2f3a666567a48bb8f98d68425a1412f9322d1271f6aa23b5da8835a4e9c1265", + "object_path": "lib/lean/Lean/Meta/Reduce.olean", + "object_sha256": "6ffb787b831080594f15ffc23525657be9c6b2fa0a7d855ff6a3a42dea774989", + "object_bytes": 341104, + "imports": [ + "Lean.Meta.Basic", + "Lean.Meta.FunInfo", + "Lean.Util.MonadCache" + ] + }, + { + "module": "Lean.Meta.Tactic.Refl", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Refl.lean", + "source_sha256": "2c756cc6d9f5f0e48c9ea13aa819b531b7cbd66d97d6322eede4ce132d3ee9b0", + "object_path": "lib/lean/Lean/Meta/Tactic/Refl.olean", + "object_sha256": "b059f1a6010f3707512dd8d2a280bada1e3937de15d43f24791afed99ac9c6fe", + "object_bytes": 161864, + "imports": [ + "Lean.Meta.Reduce", + "Lean.Meta.Tactic.Util", + "Lean.Meta.Tactic.Apply" + ] + }, + { + "module": "Lean.Meta.Tactic.Delta", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Delta.lean", + "source_sha256": "887608b8af7ddb1f46a1a0e2d5678b4cb2ff07e377bb3ded66ce8b9e23bd7705", + "object_path": "lib/lean/Lean/Meta/Tactic/Delta.olean", + "object_sha256": "43b8096fe4456e94bf587da1a62b804990d5edfe7cd484b3754fda0e53b9ea37", + "object_bytes": 130240, + "imports": [ + "Lean.Meta.Transform", + "Lean.Meta.Tactic.Replace" + ] + }, + { + "module": "Lean.Meta.Tactic.SplitIf", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/SplitIf.lean", + "source_sha256": "f8239ed5c469c9d768395bae07d72aac52e8e217bc9d07f4211a19665c494a6c", + "object_path": "lib/lean/Lean/Meta/Tactic/SplitIf.olean", + "object_sha256": "90c641c345d52381edf9b23086a297c02f04be53fdd2b00e6e3828ddd086b5fa", + "object_bytes": 989592, + "imports": [ + "Lean.Meta.Tactic.Cases", + "Lean.Meta.Tactic.Simp.Main" + ] + }, + { + "module": "Lean.Meta.Match.MatchEqs", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Match/MatchEqs.lean", + "source_sha256": "6537b00276ec7d3df71c843306d530368210c1c98ef7f27886a65bc26094b470", + "object_path": "lib/lean/Lean/Meta/Match/MatchEqs.olean", + "object_sha256": "f07ca7bb9008d2a7a0a6d47dcb85c9f04e3f7b0c0841207227407c55be60c85a", + "object_bytes": 4212896, + "imports": [ + "Lean.Meta.CtorRecognizer", + "Lean.Meta.Match.Match", + "Lean.Meta.Match.MatchEqsExt", + "Lean.Meta.Tactic.Apply", + "Lean.Meta.Tactic.Refl", + "Lean.Meta.Tactic.Delta", + "Lean.Meta.Tactic.SplitIf", + "Lean.Meta.Tactic.Injection", + "Lean.Meta.Tactic.Contradiction" + ] + }, + { + "module": "Lean.Meta.Match", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Match.lean", + "source_sha256": "c55f535138c9138842dfbf9224e7856e15fb4c51130e31b839deebb8e46e433d", + "object_path": "lib/lean/Lean/Meta/Match.olean", + "object_sha256": "aac8a2f9caf63ad1819d1004a86d0d4430280743c60e32aef4306588004c4845", + "object_bytes": 35016, + "imports": [ + "Lean.Meta.Match.MatchPatternAttr", + "Lean.Meta.Match.Match", + "Lean.Meta.Match.CaseValues", + "Lean.Meta.Match.CaseArraySizes", + "Lean.Meta.Match.MatchEqs" + ] + }, + { + "module": "Lean.Meta.Tactic.Generalize", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Generalize.lean", + "source_sha256": "eb42843dc8d3295e15c9eb3c3c6edb40ce71e0422c94c1057bdda95df311ba18", + "object_path": "lib/lean/Lean/Meta/Tactic/Generalize.olean", + "object_sha256": "e6c12a6e6c75742b2dcbf1209aaa4f07b39c50901904bf04b2c1f8e5530d9e9e", + "object_bytes": 432800, + "imports": [ + "Lean.Meta.KAbstract", + "Lean.Meta.Tactic.Util", + "Lean.Meta.Tactic.Intro", + "Lean.Meta.Tactic.FVarSubst", + "Lean.Meta.Tactic.Revert" + ] + }, + { + "module": "Lean.Meta.Tactic.Split", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Split.lean", + "source_sha256": "345466bd5a377ec7c060801e01f2d2a893f60212078227e7bc428c1f1ab5e380", + "object_path": "lib/lean/Lean/Meta/Tactic/Split.olean", + "object_sha256": "7ab00be9b4d95583aa01ddeca9fb62cabec541ae109c64cb129b72644573dbdb", + "object_bytes": 1486968, + "imports": [ + "Lean.Meta.Match.MatcherApp.Basic", + "Lean.Meta.Tactic.Simp.Main", + "Lean.Meta.Tactic.SplitIf", + "Lean.Meta.Tactic.Apply", + "Lean.Meta.Tactic.Generalize" + ] + }, + { + "module": "Lean.Meta.Match.MatcherApp.Transform", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Match/MatcherApp/Transform.lean", + "source_sha256": "cac69cf4f0ff32251f40ca5e0fb50c253b9556e65eeb6f1dbf281d2edd98eae6", + "object_path": "lib/lean/Lean/Meta/Match/MatcherApp/Transform.olean", + "object_sha256": "92874aff0b394ed35ce4ffd3dc9a6bbfee98aa4539512f03367884e5fd7a6415", + "object_bytes": 1777152, + "imports": [ + "Lean.Meta.Match", + "Lean.Meta.InferType", + "Lean.Meta.Check", + "Lean.Meta.Tactic.Split" + ] + }, + { + "module": "Lean.Elab.PreDefinition.Structural.BRecOn", + "root": "lean", + "source_path": "src/lean/Lean/Elab/PreDefinition/Structural/BRecOn.lean", + "source_sha256": "096b88d0a0ebf9ccba378a4b51ef252c353b085669f4e34c0bf7eb1e644b7ca2", + "object_path": "lib/lean/Lean/Elab/PreDefinition/Structural/BRecOn.olean", + "object_sha256": "309c39213f2511ddcfe13e85e79ee69188a5059640a78867d331432bc47c2987", + "object_bytes": 1575200, + "imports": [ + "Lean.Util.HasConstCache", + "Lean.Meta.PProdN", + "Lean.Meta.Match.MatcherApp.Transform", + "Lean.Elab.RecAppSyntax", + "Lean.Elab.PreDefinition.Basic", + "Lean.Elab.PreDefinition.Structural.Basic", + "Lean.Elab.PreDefinition.Structural.RecArgInfo" + ] + }, + { + "module": "Lean.Meta.Constructions.CasesOn", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Constructions/CasesOn.lean", + "source_sha256": "139e85192b592ec56bbc51f12102b7734c31e48de159354312351f73624ed2ab", + "object_path": "lib/lean/Lean/Meta/Constructions/CasesOn.olean", + "object_sha256": "87e0efd8d86563dde4c81e344ae99f053dfbcc6b9d8eac056a728c0ef0d92e74", + "object_bytes": 126640, + "imports": [ + "Lean.AddDecl", + "Lean.Meta.Basic" + ] + }, + { + "module": "Lean.LabelAttribute", + "root": "lean", + "source_path": "src/lean/Lean/LabelAttribute.lean", + "source_sha256": "7bb800fd11f2261156f1a04a6db2257510b8a56a8fc198e8b517b0351ed4bb86", + "object_path": "lib/lean/Lean/LabelAttribute.olean", + "object_sha256": "0eb56de1a7cd9b37969aff6f2c555a6aafb6eac8b53f95ad06a79880a6ef36f8", + "object_bytes": 392080, + "imports": [ + "Lean.ScopedEnvExtension", + "Lean.DocString" + ] + }, + { + "module": "Lean.Meta.Iterator", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Iterator.lean", + "source_sha256": "7c1457c1223893be55a2104c4377c782496950bbad5c335360553c1739a7cdcb", + "object_path": "lib/lean/Lean/Meta/Iterator.olean", + "object_sha256": "293f6784988f69526cdad300e16c520a1f1787f9a6d55a452d454c1a98618ee7", + "object_bytes": 153320, + "imports": [ + "Lean.Meta.Basic" + ] + }, + { + "module": "Lean.Meta.Tactic.IndependentOf", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/IndependentOf.lean", + "source_sha256": "f8ee4b3d34db42f03485e5e928ffe419abf575f1326a678ba2e87bf59509550d", + "object_path": "lib/lean/Lean/Meta/Tactic/IndependentOf.olean", + "object_sha256": "d09de2249910618ca518bf2ef515e0596f2c6a49b33bf43b4a7b5a45adba364b", + "object_bytes": 90024, + "imports": [ + "Lean.Meta.CollectMVars", + "Lean.Meta.Tactic.Util" + ] + }, + { + "module": "Lean.Meta.Tactic.Backtrack", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Backtrack.lean", + "source_sha256": "d1d869e6e06ed720a4aef51ff0ae670c0a74e1d708b524798a46950cf36cbf88", + "object_path": "lib/lean/Lean/Meta/Tactic/Backtrack.olean", + "object_sha256": "7c1ce64c5345dfd717e199c84b605257fbf4993d95b72f46afff23c4069b2b37", + "object_bytes": 818088, + "imports": [ + "Init.Data.List.BasicAux", + "Lean.Meta.Iterator", + "Lean.Meta.Tactic.IndependentOf" + ] + }, + { + "module": "Lean.Meta.Tactic.Constructor", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Constructor.lean", + "source_sha256": "34ed06d1bc13390cd931ce7565fbcf4a34929cbbfa0e88b0c4bba826c4d5b4d8", + "object_path": "lib/lean/Lean/Meta/Tactic/Constructor.olean", + "object_sha256": "d8808b273b5766304a72682a96ee0a4ce9d66e017ef8dad93add4c27dee5474d", + "object_bytes": 252024, + "imports": [ + "Lean.Meta.Check", + "Lean.Meta.Tactic.Util", + "Lean.Meta.Tactic.Apply" + ] + }, + { + "module": "Lean.Meta.Tactic.Repeat", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Repeat.lean", + "source_sha256": "3c7e6443ccff14ff79d8cc18968641039256743b5dc7ac6a7071406404483114", + "object_path": "lib/lean/Lean/Meta/Tactic/Repeat.olean", + "object_sha256": "3b1a312a007633be0c3ec6190cc98b9d121fd6c02ec8466194fd0fb45d2d00e8", + "object_bytes": 449880, + "imports": [ + "Lean.Meta.Basic" + ] + }, + { + "module": "Lean.Meta.Tactic.Symm", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Symm.lean", + "source_sha256": "6417d7594137f4c8d45d3d14caca43341e81628aa92a125d5085e817e859c509", + "object_path": "lib/lean/Lean/Meta/Tactic/Symm.olean", + "object_sha256": "11dca0c0ac414070a2a0fc806a9a4534466dfbe2da1115426428249241890bc0", + "object_bytes": 761768, + "imports": [ + "Lean.Meta.Reduce", + "Lean.Meta.Tactic.Assert" + ] + }, + { + "module": "Lean.Meta.Tactic.SolveByElim", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/SolveByElim.lean", + "source_sha256": "58690436fa21d20dec9697ce4844cd1f122a6fe1858bcf2f0f4de283e963df22", + "object_path": "lib/lean/Lean/Meta/Tactic/SolveByElim.olean", + "object_sha256": "52bd7ef93167df4c7df4def260be119c6a8e09a698abff0b9054bdab67bad269", + "object_bytes": 824992, + "imports": [ + "Init.Data.Sum", + "Lean.LabelAttribute", + "Lean.Meta.Tactic.Apply", + "Lean.Meta.Tactic.Backtrack", + "Lean.Meta.Tactic.Constructor", + "Lean.Meta.Tactic.Repeat", + "Lean.Meta.Tactic.Symm", + "Lean.Elab.Term" + ] + }, + { + "module": "Lean.Meta.IndPredBelow", + "root": "lean", + "source_path": "src/lean/Lean/Meta/IndPredBelow.lean", + "source_sha256": "10f50a540ba764d3e0cefbfea896320e47476dcfc06996a6a860ad3c83421ab7", + "object_path": "lib/lean/Lean/Meta/IndPredBelow.olean", + "object_sha256": "5861110ae9c310a24e4ca7503f3c5772dfcd09e0898a7eac5880c15fc7a33a0b", + "object_bytes": 2432240, + "imports": [ + "Lean.Meta.Constructions.CasesOn", + "Lean.Meta.Match.Match", + "Lean.Meta.Tactic.SolveByElim" + ] + }, + { + "module": "Lean.Elab.PreDefinition.Structural.IndPred", + "root": "lean", + "source_path": "src/lean/Lean/Elab/PreDefinition/Structural/IndPred.lean", + "source_sha256": "bda780ef9f1d0b73cc55d94638e7da9dc0c515e8715dbeaa2f1376d0f9b56498", + "object_path": "lib/lean/Lean/Elab/PreDefinition/Structural/IndPred.olean", + "object_sha256": "91e2a05f0653005fee772fa2f90e88da4b13d596c374faca94f861b161f7b728", + "object_bytes": 1145088, + "imports": [ + "Lean.Meta.IndPredBelow", + "Lean.Elab.PreDefinition.Basic", + "Lean.Elab.PreDefinition.Structural.Basic", + "Lean.Elab.PreDefinition.Structural.RecArgInfo" + ] + }, + { + "module": "Lean.Elab.PreDefinition.Eqns", + "root": "lean", + "source_path": "src/lean/Lean/Elab/PreDefinition/Eqns.lean", + "source_sha256": "209edfa945c097db733d96dd88a3546ef15c1315de463c824dd4d185e270b571", + "object_path": "lib/lean/Lean/Elab/PreDefinition/Eqns.olean", + "object_sha256": "ddd7e88e1fb0f32d8d54c92ab714152c4b1f73fb455066614074610d1a747d68", + "object_bytes": 2537568, + "imports": [ + "Lean.Meta.Eqns", + "Lean.Meta.CtorRecognizer", + "Lean.Util.CollectFVars", + "Lean.Util.ForEachExprWhere", + "Lean.Meta.Tactic.Split", + "Lean.Meta.Tactic.Apply", + "Lean.Meta.Tactic.Refl", + "Lean.Meta.Match.MatchEqs" + ] + }, + { + "module": "Lean.Elab.PreDefinition.Structural.Eqns", + "root": "lean", + "source_path": "src/lean/Lean/Elab/PreDefinition/Structural/Eqns.lean", + "source_sha256": "865d9c8af935459d8ddb826043a2159cf13e552d5be5afe44d5e34b88086b7b6", + "object_path": "lib/lean/Lean/Elab/PreDefinition/Structural/Eqns.olean", + "object_sha256": "cdaf9bdb00b09c248c92382c1f94052ba6fc06049a1840eb7a67bad1809524d7", + "object_bytes": 584920, + "imports": [ + "Lean.Meta.Eqns", + "Lean.Meta.Tactic.Split", + "Lean.Meta.Tactic.Simp.Main", + "Lean.Meta.Tactic.Apply", + "Lean.Elab.PreDefinition.Basic", + "Lean.Elab.PreDefinition.Eqns", + "Lean.Elab.PreDefinition.FixedParams", + "Lean.Elab.PreDefinition.Structural.Basic" + ] + }, + { + "module": "Lean.Elab.PreDefinition.Structural.SmartUnfolding", + "root": "lean", + "source_path": "src/lean/Lean/Elab/PreDefinition/Structural/SmartUnfolding.lean", + "source_sha256": "8abbdd38eccbff92f74861053a6a8d66e1f93453c73988148323eaadab576e49", + "object_path": "lib/lean/Lean/Elab/PreDefinition/Structural/SmartUnfolding.olean", + "object_sha256": "5dff53021aa3c1c0b2122f76bc15baaed6fc548f83a66bd02e65737c201f5448", + "object_bytes": 309632, + "imports": [ + "Lean.Elab.PreDefinition.Basic", + "Lean.Elab.PreDefinition.Structural.Basic", + "Lean.Meta.Match.MatcherApp.Basic" + ] + }, + { + "module": "Lean.Elab.Do", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Do.lean", + "source_sha256": "f4259447957597ec00e7e470e73b88f9409994891f542d09321630d9dcd2472a", + "object_path": "lib/lean/Lean/Elab/Do.olean", + "object_sha256": "cae0b2a9e89c86e27157c7d6d6aa6173d7549e1864a22c05c8e755739d69119e", + "object_bytes": 5799432, + "imports": [ + "Lean.Elab.Term", + "Lean.Elab.BindersUtil", + "Lean.Elab.PatternVar", + "Lean.Elab.Quotation.Util", + "Lean.Parser.Do" + ] + }, + { + "module": "Lean.Server.FileWorker.ExampleHover", + "root": "lean", + "source_path": "src/lean/Lean/Server/FileWorker/ExampleHover.lean", + "source_sha256": "fc853fdb3a352b6176799b0a2c359f5388dbd06a85621335f9a5e0e649f10d07", + "object_path": "lib/lean/Lean/Server/FileWorker/ExampleHover.olean", + "object_sha256": "35b3c34cb8fc6633c459aa12373ead5ef3590f9cba31273d85c3d31969a7bd31", + "object_bytes": 267448, + "imports": [ + "Lean.Elab.Do" + ] + }, + { + "module": "Lean.Server.GoTo", + "root": "lean", + "source_path": "src/lean/Lean/Server/GoTo.lean", + "source_sha256": "2bb79a5c5f825cecbb304fc42f30c82aa1a16c09caa70fe6ac038e807499b7a3", + "object_path": "lib/lean/Lean/Server/GoTo.olean", + "object_sha256": "87ff86194cdec917de64fb223d007bc28cacef3a9b00ce702d839834dfea48e9", + "object_bytes": 172568, + "imports": [ + "Lean.Data.Json.FromToJson", + "Lean.Util.Path", + "Lean.Server.Utils" + ] + }, + { + "module": "Lean.Server.ServerTask", + "root": "lean", + "source_path": "src/lean/Lean/Server/ServerTask.lean", + "source_sha256": "23a4a949fa2a667db11884dcee03ca233ba0c2b968d9e270db50546ccb9a694c", + "object_path": "lib/lean/Lean/Server/ServerTask.olean", + "object_sha256": "103fee24245d768473fd7e81a5f2bc8d89b3365fa5e255feae72bfcf7ad5e2eb", + "object_bytes": 246992, + "imports": [ + "Init.System.IO" + ] + }, + { + "module": "Lean.Server.RequestCancellation", + "root": "lean", + "source_path": "src/lean/Lean/Server/RequestCancellation.lean", + "source_sha256": "7cfbe563cb9024ac394640d158bdb612cf0b74b58937cb158d5b43cc0c87e458", + "object_path": "lib/lean/Lean/Server/RequestCancellation.olean", + "object_sha256": "1f040cbe504e921ea5ed5bbb61fe85d43bdd8661eefee39f87253c03a96fd505", + "object_bytes": 185928, + "imports": [ + "Init.System.Promise", + "Lean.Server.ServerTask" + ] + }, + { + "module": "Lean.Server.FileSource", + "root": "lean", + "source_path": "src/lean/Lean/Server/FileSource.lean", + "source_sha256": "8518b2d200bca29f84d5dda9a8e465a96e6e346c87448fbfdcf96a1a6651f23a", + "object_path": "lib/lean/Lean/Server/FileSource.olean", + "object_sha256": "017c0c3a6d0e0b6868571d1c1b89537fa9b05403460d3a1d9c2bfedef35279e5", + "object_bytes": 95400, + "imports": [ + "Lean.Data.Lsp" + ] + }, + { + "module": "Lean.Linter.UnusedVariables", + "root": "lean", + "source_path": "src/lean/Lean/Linter/UnusedVariables.lean", + "source_sha256": "f4f2be441eb983334e6db1a42e7867c35490d4f3cfc226b95b133897b9cf43c3", + "object_path": "lib/lean/Lean/Linter/UnusedVariables.olean", + "object_sha256": "6e47d5762d423c3535fd5e29af66f8ea91484e28f1299e7286e2bedf8a83f855", + "object_bytes": 2019232, + "imports": [ + "Lean.Elab.Command", + "Lean.Linter.Util" + ] + }, + { + "module": "Lean.Widget.TaggedText", + "root": "lean", + "source_path": "src/lean/Lean/Widget/TaggedText.lean", + "source_sha256": "2c296d5c56d082e20c0751d89cfa7ccbd63df90125fc55f34acfdc6b378930cc", + "object_path": "lib/lean/Lean/Widget/TaggedText.olean", + "object_sha256": "cb4760567ee3a0f19e80a8fa2ad2097dfe2c7f822a16d51e6cbd365b5cdb22b8", + "object_bytes": 783064, + "imports": [ + "Lean.Data.Json.FromToJson", + "Lean.Server.Rpc.Basic" + ] + }, + { + "module": "Lean.Widget.Basic", + "root": "lean", + "source_path": "src/lean/Lean/Widget/Basic.lean", + "source_sha256": "fc48fd11c4bc38f0eb349318ae934a0f2d4bc8be28192fbc364c1a6938c5afea", + "object_path": "lib/lean/Lean/Widget/Basic.olean", + "object_sha256": "782af53e06ddc5a6959ea7206fc65c12a812649a7b5364e70e41c3ad2afc06ec", + "object_bytes": 36568, + "imports": [ + "Lean.Elab.InfoTree", + "Lean.Message", + "Lean.Server.Rpc.Basic", + "Lean.Server.InfoUtils", + "Lean.Widget.Types" + ] + }, + { + "module": "Lean.Widget.InteractiveCode", + "root": "lean", + "source_path": "src/lean/Lean/Widget/InteractiveCode.lean", + "source_sha256": "e6398ed12729a7c5f432790e1acc56f0aae088ead81ecc0a214b05b4ca437821", + "object_path": "lib/lean/Lean/Widget/InteractiveCode.olean", + "object_sha256": "0e8df8208feef2f70bcf4914ca732ae5827a6b0550a9e76f13878551e7ea90eb", + "object_bytes": 413776, + "imports": [ + "Lean.Server.Rpc.Basic", + "Lean.Server.InfoUtils", + "Lean.Widget.TaggedText", + "Lean.Widget.Basic" + ] + }, + { + "module": "Lean.Widget.InteractiveGoal", + "root": "lean", + "source_path": "src/lean/Lean/Widget/InteractiveGoal.lean", + "source_sha256": "29a8a88b08fbdb45c9089c6179a7ac90185f84921ee1addad780d7a5b3eb28d7", + "object_path": "lib/lean/Lean/Widget/InteractiveGoal.olean", + "object_sha256": "6f005ad19a128d6d37f96670889491f4426745733ca16e8f31718e589f50803b", + "object_bytes": 1437504, + "imports": [ + "Lean.Meta.PPGoal", + "Lean.Widget.InteractiveCode", + "Lean.Data.Lsp.Extra" + ] + }, + { + "module": "Lean.Widget.InteractiveDiagnostic", + "root": "lean", + "source_path": "src/lean/Lean/Widget/InteractiveDiagnostic.lean", + "source_sha256": "0b54fad1cccbab5a78bda44a9584f4f0696c25236a69d3a7a51c560b91c3e55f", + "object_path": "lib/lean/Lean/Widget/InteractiveDiagnostic.olean", + "object_sha256": "a1973946335101dd80a1f3c4b78e46027cc8a5128926ae1fe9a4c33740400a23", + "object_bytes": 1972192, + "imports": [ + "Lean.Linter.UnusedVariables", + "Lean.Server.Utils", + "Lean.Widget.InteractiveGoal" + ] + }, + { + "module": "Lean.Server.Snapshots", + "root": "lean", + "source_path": "src/lean/Lean/Server/Snapshots.lean", + "source_sha256": "5397897f8c8527d5e0b119a09f23f780e1f3dfd56066ed069b35cd37745fc538", + "object_path": "lib/lean/Lean/Server/Snapshots.olean", + "object_sha256": "46bbd254869cd2802bd5c11f7025a124819d4144b1241e2a65ebd0860d4ef9cd", + "object_bytes": 122696, + "imports": [ + "Init.System.IO", + "Lean.Elab.Import", + "Lean.Elab.Command", + "Lean.Widget.InteractiveDiagnostic" + ] + }, + { + "module": "Lean.Server.AsyncList", + "root": "lean", + "source_path": "src/lean/Lean/Server/AsyncList.lean", + "source_sha256": "a9b0a36203c89516caae311f3287ebfedccc8286b8a631824fe866e1951ef8a4", + "object_path": "lib/lean/Lean/Server/AsyncList.olean", + "object_sha256": "5b8d3c52e9dc6b13d50c2ad1bfeb22034d678c2b62628646717edc74c002cc0b", + "object_bytes": 384744, + "imports": [ + "Lean.Server.ServerTask", + "Init.System.Promise" + ] + }, + { + "module": "Lean.Server.FileWorker.Utils", + "root": "lean", + "source_path": "src/lean/Lean/Server/FileWorker/Utils.lean", + "source_sha256": "228b1e5ea157fef373abf408a34e887f680078cba1abc7fe3185c50289e72905", + "object_path": "lib/lean/Lean/Server/FileWorker/Utils.olean", + "object_sha256": "a4ae996c76a3247318d1ff0a456e3dd363eecc945b0aea8c3e1fcc0cb0e755ba", + "object_bytes": 191528, + "imports": [ + "Lean.Language.Lean.Types", + "Lean.Server.Utils", + "Lean.Server.Snapshots", + "Lean.Server.AsyncList", + "Lean.Server.Rpc.Basic" + ] + }, + { + "module": "Std.Sync.Basic", + "root": "lean", + "source_path": "src/lean/Std/Sync/Basic.lean", + "source_sha256": "76cf5a7c19b34d92ed0111e4e22abec4ecbc9dbb1f83d3e57a0a19ec612dc2c8", + "object_path": "lib/lean/Std/Sync/Basic.olean", + "object_sha256": "3a04db6c38b2607ceccfda83ecf9d31c5755ae26c6be1fe311c514694b67dac7", + "object_bytes": 20176, + "imports": [ + "Init.System.IO", + "Init.Control.StateRef" + ] + }, + { + "module": "Std.Sync.Mutex", + "root": "lean", + "source_path": "src/lean/Std/Sync/Mutex.lean", + "source_sha256": "24851598b58846c4e598f7a444084560152097e236e9ad01255b21834df8d41a", + "object_path": "lib/lean/Std/Sync/Mutex.olean", + "object_sha256": "626bbadc699defa26f071134142a461d99070043d7f9b4e541bd442dc112657f", + "object_bytes": 188872, + "imports": [ + "Std.Sync.Basic" + ] + }, + { + "module": "Lean.Server.Requests", + "root": "lean", + "source_path": "src/lean/Lean/Server/Requests.lean", + "source_sha256": "143a2a99a8b5d5b89fbdf655ea654359c714aa06e984a315552202bc541ea6b5", + "object_path": "lib/lean/Lean/Server/Requests.olean", + "object_sha256": "f1bd030b92aa9d068838d6acc1ade962a39fee843500cc07dd4bfd9b4d9aa84e", + "object_bytes": 1320528, + "imports": [ + "Lean.DeclarationRange", + "Lean.Data.Json", + "Lean.Data.Lsp", + "Lean.Elab.Command", + "Lean.Server.RequestCancellation", + "Lean.Server.ServerTask", + "Lean.Server.FileSource", + "Lean.Server.FileWorker.Utils", + "Lean.Server.Rpc.Basic", + "Std.Sync.Mutex" + ] + }, + { + "module": "Lean.Server.FileWorker.InlayHints", + "root": "lean", + "source_path": "src/lean/Lean/Server/FileWorker/InlayHints.lean", + "source_sha256": "a49b3513544e09d3b6a1ee5a68b3ce5fc25a7b0ab5d224f0b00c48f7c8326759", + "object_path": "lib/lean/Lean/Server/FileWorker/InlayHints.olean", + "object_sha256": "4296753e3aa868ba118232d7d4f78e5e2f60b37e233519ca282c5987bc8fed0d", + "object_bytes": 833304, + "imports": [ + "Lean.Server.GoTo", + "Lean.Server.Requests" + ] + }, + { + "module": "Lean.Server.FileWorker.SemanticHighlighting", + "root": "lean", + "source_path": "src/lean/Lean/Server/FileWorker/SemanticHighlighting.lean", + "source_sha256": "7af83e432cdc603babb829b3d74954943871995b710fb0a9f2945f25eeed34ec", + "object_path": "lib/lean/Lean/Server/FileWorker/SemanticHighlighting.olean", + "object_sha256": "42a100debaad1bc5c653d44c72bc40dd83d256c0666cf8a05a43be84ed144bec", + "object_bytes": 890600, + "imports": [ + "Lean.Server.Requests" + ] + }, + { + "module": "Lean.Data.FuzzyMatching", + "root": "lean", + "source_path": "src/lean/Lean/Data/FuzzyMatching.lean", + "source_sha256": "99ed088ea53df21c1c9bae2e32cf4520d111f0c8ebd33380623da7fd2097a072", + "object_path": "lib/lean/Lean/Data/FuzzyMatching.olean", + "object_sha256": "8f3e9df2efa273a673844b611542d656c93270a569a6f92727cf19a1f14c4a3b", + "object_bytes": 490072, + "imports": [ + "Init.Data.Range", + "Init.Data.OfScientific", + "Init.Data.Option.Coe" + ] + }, + { + "module": "Lean.Elab.Tactic.Doc", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/Doc.lean", + "source_sha256": "010f2cedb8c5340b20cc5db760c2f39e57119e23d09bab47e30d3f5e407a7d44", + "object_path": "lib/lean/Lean/Elab/Tactic/Doc.olean", + "object_sha256": "b515664945e155a71e83211945e85f1ff348d565c1640d901a1729afdcfd35c9", + "object_bytes": 1185456, + "imports": [ + "Lean.DocString", + "Lean.Elab.Command", + "Lean.Parser.Tactic.Doc", + "Lean.Parser.Command" + ] + }, + { + "module": "Lean.Server.Completion.CompletionItemData", + "root": "lean", + "source_path": "src/lean/Lean/Server/Completion/CompletionItemData.lean", + "source_sha256": "e29d78cc0b63ccb7c5a7bd605b3200e97124a2c500b9a98437fe6c2b52573452", + "object_path": "lib/lean/Lean/Server/Completion/CompletionItemData.olean", + "object_sha256": "108df4282f057c80a378de7dfd7392a16b4b7701b10b8e09e1d35f5b65bfa9bc", + "object_bytes": 102824, + "imports": [ + "Lean.Server.FileSource" + ] + }, + { + "module": "Lean.Server.Completion.CompletionUtils", + "root": "lean", + "source_path": "src/lean/Lean/Server/Completion/CompletionUtils.lean", + "source_sha256": "ce9b08e9fd4ab529aa8ca020a2938b01203386e8bc0fa15aaecace3ff7e97661", + "object_path": "lib/lean/Lean/Server/Completion/CompletionUtils.olean", + "object_sha256": "1732d36b5374a47c6777156a6a55d304e2ad00452642a5d6cc178057288c3fbe", + "object_bytes": 493120, + "imports": [ + "Init.Prelude", + "Lean.Meta.WHNF" + ] + }, + { + "module": "Lean.Server.Completion.SyntheticCompletion", + "root": "lean", + "source_path": "src/lean/Lean/Server/Completion/SyntheticCompletion.lean", + "source_sha256": "f44c25a2178e4a42a2750bd1efd873910b28e5e6b5493d628f140ba44a146833", + "object_path": "lib/lean/Lean/Server/Completion/SyntheticCompletion.olean", + "object_sha256": "2bb4be78640e1610c9ffd4a410d904d74ea8d368b1fa9d19e7ed27059fd5bc8e", + "object_bytes": 580680, + "imports": [ + "Lean.Server.InfoUtils", + "Lean.Server.Completion.CompletionUtils" + ] + }, + { + "module": "Lean.Server.Completion.CompletionInfoSelection", + "root": "lean", + "source_path": "src/lean/Lean/Server/Completion/CompletionInfoSelection.lean", + "source_sha256": "ffad56a9820d2b7ea59961b61da9a651dceabd6a2113b145f6431a373642f43f", + "object_path": "lib/lean/Lean/Server/Completion/CompletionInfoSelection.olean", + "object_sha256": "89cfc8dc48bb9c0cbd648e538dd98414111e85538e14eac5a22c01bf3d6d31e4", + "object_bytes": 391744, + "imports": [ + "Lean.Server.Completion.SyntheticCompletion" + ] + }, + { + "module": "Lean.Server.Completion.CompletionResolution", + "root": "lean", + "source_path": "src/lean/Lean/Server/Completion/CompletionResolution.lean", + "source_sha256": "0310f7498bd2f34f10d1dc9803a9595c7088ecb68de94248ab2277c5f1416f41", + "object_path": "lib/lean/Lean/Server/Completion/CompletionResolution.olean", + "object_sha256": "cc3e227c36b587470f4c41c9e4d037d280e3afde6bb22bd900e717cbd09d6820", + "object_bytes": 393112, + "imports": [ + "Lean.Server.Completion.CompletionItemData", + "Lean.Server.Completion.CompletionInfoSelection", + "Lean.Linter.Deprecated" + ] + }, + { + "module": "Lean.Meta.CompletionName", + "root": "lean", + "source_path": "src/lean/Lean/Meta/CompletionName.lean", + "source_sha256": "f66a64aac8d85619a51a00c1103b1566aacb18f7a232eeeef8afa9ea7b5e1c0f", + "object_path": "lib/lean/Lean/Meta/CompletionName.olean", + "object_sha256": "c2984c13594695cc9a3adaef1336612101945af7c75d4a393fa89cd24b345d9f", + "object_bytes": 62792, + "imports": [ + "Lean.Meta.Basic", + "Lean.Meta.Match.MatcherInfo" + ] + }, + { + "module": "Lean.Server.Completion.EligibleHeaderDecls", + "root": "lean", + "source_path": "src/lean/Lean/Server/Completion/EligibleHeaderDecls.lean", + "source_sha256": "d5e7889506b900ce85608208c1f1c99e2645a9117255a86ed286ae1246a93c0c", + "object_path": "lib/lean/Lean/Server/Completion/EligibleHeaderDecls.olean", + "object_sha256": "d02ed6addf3d3f276b0443d7659c38878ff733acbe5c39ca103016976b256457", + "object_bytes": 191824, + "imports": [ + "Lean.Meta.CompletionName" + ] + }, + { + "module": "Lean.Server.Completion.CompletionCollectors", + "root": "lean", + "source_path": "src/lean/Lean/Server/Completion/CompletionCollectors.lean", + "source_sha256": "a46b871cf15ec953b04b404528b0818178728d1947b186a1c312dfa9e7f7765e", + "object_path": "lib/lean/Lean/Server/Completion/CompletionCollectors.olean", + "object_sha256": "869da7b86fb4fb66cb9c0b79c475c7c2dca49e0b1d961a47d4f6ce2f140a4961", + "object_bytes": 1830912, + "imports": [ + "Lean.Data.FuzzyMatching", + "Lean.Elab.Tactic.Doc", + "Lean.Server.Completion.CompletionResolution", + "Lean.Server.Completion.EligibleHeaderDecls", + "Lean.Server.RequestCancellation", + "Lean.Server.Completion.CompletionUtils" + ] + }, + { + "module": "Std.Data.DHashMap.Internal.Raw", + "root": "lean", + "source_path": "src/lean/Std/Data/DHashMap/Internal/Raw.lean", + "source_sha256": "d01bb86cc41b1ef7be0613c4965e52cac6a73cb9dff352f9b72b8799f3410a37", + "object_path": "lib/lean/Std/Data/DHashMap/Internal/Raw.olean", + "object_sha256": "b15844ef54debcd8278112bdb48a1167721ef4dddfa6fd83a758f8ced38c9317", + "object_bytes": 329480, + "imports": [ + "Std.Data.DHashMap.Basic" + ] + }, + { + "module": "Std.Data.DHashMap.Internal.HashesTo", + "root": "lean", + "source_path": "src/lean/Std/Data/DHashMap/Internal/HashesTo.lean", + "source_sha256": "f582668a08a3bcf3472611f797bb77d496fdf85da07e038c602f8884c2ec7276", + "object_path": "lib/lean/Std/Data/DHashMap/Internal/HashesTo.olean", + "object_sha256": "5e60b1e1128bc9fffbcc51b51efca51f9e493d718e074b7579ac1fa94146e7b0", + "object_bytes": 75408, + "imports": [ + "Init.Data.Hashable", + "Std.Data.Internal.List.Associative", + "Std.Data.DHashMap.Internal.Defs" + ] + }, + { + "module": "Std.Data.DHashMap.Internal.AssocList.Lemmas", + "root": "lean", + "source_path": "src/lean/Std/Data/DHashMap/Internal/AssocList/Lemmas.lean", + "source_sha256": "189c336c49e4dda16da22dea14f741aef74a7d5367a18f4d55003297c1cf9512", + "object_path": "lib/lean/Std/Data/DHashMap/Internal/AssocList/Lemmas.olean", + "object_sha256": "c18a13c7cc6da3755920d56915e1f7cf3054b12711f45722d8f2796e1f94e3b0", + "object_bytes": 604264, + "imports": [ + "Std.Data.DHashMap.Internal.AssocList.Basic", + "Std.Data.Internal.List.Associative" + ] + }, + { + "module": "Std.Data.DHashMap.Internal.Model", + "root": "lean", + "source_path": "src/lean/Std/Data/DHashMap/Internal/Model.lean", + "source_sha256": "789b4b819f7c6b97c82a29cbdf134eb9c87e26578e2345a1f18dc85d5bf82077", + "object_path": "lib/lean/Std/Data/DHashMap/Internal/Model.olean", + "object_sha256": "7b4e8f8f00c674eed1bb0186ea11ccf32544ef965bb6a1625524796a433fe1e4", + "object_bytes": 1651112, + "imports": [ + "Init.Data.Array.TakeDrop", + "Std.Data.DHashMap.Basic", + "Std.Data.DHashMap.Internal.HashesTo", + "Std.Data.DHashMap.Internal.AssocList.Lemmas" + ] + }, + { + "module": "Std.Data.DHashMap.Internal.WF", + "root": "lean", + "source_path": "src/lean/Std/Data/DHashMap/Internal/WF.lean", + "source_sha256": "d4002a4860d088edceae8440ed093c02ab7e0951e3a3a12b406e8c113359f9b7", + "object_path": "lib/lean/Std/Data/DHashMap/Internal/WF.olean", + "object_sha256": "71ab0db470ce3788b8088a5417600835d322244f7fa71cebf7f3dc12b50a2fa4", + "object_bytes": 1495600, + "imports": [ + "Std.Data.DHashMap.Basic", + "Std.Data.DHashMap.Internal.Model", + "Std.Data.DHashMap.Internal.AssocList.Lemmas" + ] + }, + { + "module": "Std.Data.DHashMap.Internal.RawLemmas", + "root": "lean", + "source_path": "src/lean/Std/Data/DHashMap/Internal/RawLemmas.lean", + "source_sha256": "f7f44e0ac8f6d4b5e940c3d2fdb61c0acf52fd90f319a3b6fd6c7842ff6092cf", + "object_path": "lib/lean/Std/Data/DHashMap/Internal/RawLemmas.olean", + "object_sha256": "f6e41fd19d3bf6d46755fb308e9f848ad02e6db5f76a41035814181990eb2b69", + "object_bytes": 5796072, + "imports": [ + "Std.Data.DHashMap.Internal.WF" + ] + }, + { + "module": "Std.Data.DHashMap.AdditionalOperations", + "root": "lean", + "source_path": "src/lean/Std/Data/DHashMap/AdditionalOperations.lean", + "source_sha256": "f1f3d705c954d04fa2c3feb69e213b088a4a530c4e39f4f846cb27553ded559a", + "object_path": "lib/lean/Std/Data/DHashMap/AdditionalOperations.olean", + "object_sha256": "60bfe0e53e893b9cff892c566b1d17a762d650b424c5a3fc5feb8bf7955e5735", + "object_bytes": 99768, + "imports": [ + "Std.Data.DHashMap.Internal.Raw", + "Std.Data.DHashMap.Internal.WF" + ] + }, + { + "module": "Std.Data.DHashMap.Lemmas", + "root": "lean", + "source_path": "src/lean/Std/Data/DHashMap/Lemmas.lean", + "source_sha256": "ecd63758f713357f58325ee81989ce36a6afa5d221350505f6a8038f4192a920", + "object_path": "lib/lean/Std/Data/DHashMap/Lemmas.olean", + "object_sha256": "50375761853edb767a3c717609d80bd6a30779fb50e4fd3794c062ba59565fe9", + "object_bytes": 2842208, + "imports": [ + "Std.Data.DHashMap.Internal.Raw", + "Std.Data.DHashMap.Internal.RawLemmas", + "Std.Data.DHashMap.AdditionalOperations" + ] + }, + { + "module": "Std.Data.HashMap.AdditionalOperations", + "root": "lean", + "source_path": "src/lean/Std/Data/HashMap/AdditionalOperations.lean", + "source_sha256": "d3059654067c15529e8f82f1c4f64c285a2bdc31f58aa64255f3019cd44908a2", + "object_path": "lib/lean/Std/Data/HashMap/AdditionalOperations.olean", + "object_sha256": "40ccfb538baefe3ddabd31f31c93062ef0c91650fbd48fbfd9c8565477fc1c9a", + "object_bytes": 88040, + "imports": [ + "Std.Data.DHashMap.AdditionalOperations", + "Std.Data.HashMap.Basic", + "Std.Data.HashMap.Raw" + ] + }, + { + "module": "Std.Data.HashMap.Lemmas", + "root": "lean", + "source_path": "src/lean/Std/Data/HashMap/Lemmas.lean", + "source_sha256": "fcd20d458e4fc11bfa1ff19f84f241106e2dce47b4d9bcb352ec7d064de462b5", + "object_path": "lib/lean/Std/Data/HashMap/Lemmas.olean", + "object_sha256": "d30a1547b7578fe418f33971034cc2468f33182ce7da3aa0c5ff149bba3771be", + "object_bytes": 1491152, + "imports": [ + "Std.Data.DHashMap.Lemmas", + "Std.Data.HashMap.Basic", + "Std.Data.HashMap.AdditionalOperations" + ] + }, + { + "module": "Std.Data.HashMap", + "root": "lean", + "source_path": "src/lean/Std/Data/HashMap.lean", + "source_sha256": "d73671263b5f58f49680b3abc95b6b521775a260e41496b4b15d1d044ec7a1ba", + "object_path": "lib/lean/Std/Data/HashMap.olean", + "object_sha256": "0a652b9053c122ca75917db28b8843fed1a45b10f3e2d50661b21f1529d7a4fe", + "object_bytes": 18256, + "imports": [ + "Std.Data.HashMap.Basic", + "Std.Data.HashMap.Lemmas", + "Std.Data.HashMap.AdditionalOperations" + ] + }, + { + "module": "Lean.Server.Completion", + "root": "lean", + "source_path": "src/lean/Lean/Server/Completion.lean", + "source_sha256": "db398ef1a5fd5382c8c188f03aaad40610eadd2a2e9aec79978124324b2dc202", + "object_path": "lib/lean/Lean/Server/Completion.olean", + "object_sha256": "c4cdbd6a8d565ffd618acd6a39112d5619067d9e8ece031281d78c8da25b69f7", + "object_bytes": 373520, + "imports": [ + "Lean.Server.Completion.CompletionCollectors", + "Lean.Server.RequestCancellation", + "Std.Data.HashMap" + ] + }, + { + "module": "Lean.Widget.Diff", + "root": "lean", + "source_path": "src/lean/Lean/Widget/Diff.lean", + "source_sha256": "259538732dac506150cbba6a8ba151979cc0a5018d65f6617fcb9fad3760b157", + "object_path": "lib/lean/Lean/Widget/Diff.olean", + "object_sha256": "590364aeb882dd44314d291e9299fa3a47262d5f44fddb744a54734f83fd0a1c", + "object_bytes": 1039992, + "imports": [ + "Lean.Meta.PPGoal", + "Lean.Widget.InteractiveCode", + "Lean.Widget.InteractiveGoal", + "Lean.Data.Lsp.Extra", + "Lean.Elab.InfoTree" + ] + }, + { + "module": "Lean.Server.FileWorker.RequestHandling", + "root": "lean", + "source_path": "src/lean/Lean/Server/FileWorker/RequestHandling.lean", + "source_sha256": "a3cf8bb351a4ddb156f3f893c595fc12b92f3232a91c91d1dbb6e50c6c214169", + "object_path": "lib/lean/Lean/Server/FileWorker/RequestHandling.olean", + "object_sha256": "dc08a093200e77159f927c49141a582bec10cbfc866001b86ca296a65a7e6fd1", + "object_bytes": 2417392, + "imports": [ + "Lean.Server.FileWorker.ExampleHover", + "Lean.Server.FileWorker.InlayHints", + "Lean.Server.FileWorker.SemanticHighlighting", + "Lean.Server.Completion", + "Lean.Server.References", + "Lean.Widget.Diff" + ] + }, + { + "module": "Lean.Server.CodeActions.Basic", + "root": "lean", + "source_path": "src/lean/Lean/Server/CodeActions/Basic.lean", + "source_sha256": "4c486e51edd626545d87fecf6de7d74924d0c8866aca3ca2abdab093d0b96df7", + "object_path": "lib/lean/Lean/Server/CodeActions/Basic.olean", + "object_sha256": "20f515f0aeff4a60d650f89cd9ddc8eb8b0d2e26f0dac5b97e4695cce5693bff", + "object_bytes": 573168, + "imports": [ + "Lean.Server.FileWorker.RequestHandling", + "Lean.Server.InfoUtils" + ] + }, + { + "module": "Lean.Server.CodeActions.Attr", + "root": "lean", + "source_path": "src/lean/Lean/Server/CodeActions/Attr.lean", + "source_sha256": "5aeecde5e922f81d83b2ba1e5c69bcd9cb2bb9711074f4b372a572f384d46fa7", + "object_path": "lib/lean/Lean/Server/CodeActions/Attr.olean", + "object_sha256": "35477b18a11ef7d70d86b84d8ad6986b6cf6d952baef94182db05d085feef0fa", + "object_bytes": 517664, + "imports": [ + "Lean.Server.CodeActions.Basic" + ] + }, + { + "module": "Lean.Elab.Open", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Open.lean", + "source_sha256": "13cd96ba3b0e88f596ed0cc75c98cb270890c77b8545398c80008c003ae96ff6", + "object_path": "lib/lean/Lean/Elab/Open.olean", + "object_sha256": "a15e428f7bdcd26aa105cc577780161e0d31e253dae431d686668e70746701d9", + "object_bytes": 1037584, + "imports": [ + "Lean.Log", + "Lean.Elab.Util" + ] + }, + { + "module": "Lean.Elab.BuiltinTerm", + "root": "lean", + "source_path": "src/lean/Lean/Elab/BuiltinTerm.lean", + "source_sha256": "83a05c771a175454f14deac11d0348b4fdba561f21dd409f361a8e76e4c7a8b6", + "object_path": "lib/lean/Lean/Elab/BuiltinTerm.olean", + "object_sha256": "751b557c3ff6aedf03ce4ecfd3e7bbcba3915063802633bb65bc9c03b3d080c0", + "object_bytes": 2081504, + "imports": [ + "Lean.Meta.Closure", + "Lean.Meta.Diagnostics", + "Lean.Elab.Open", + "Lean.Elab.SetOption", + "Lean.Elab.Eval" + ] + }, + { + "module": "Lean.Server.CodeActions.Provider", + "root": "lean", + "source_path": "src/lean/Lean/Server/CodeActions/Provider.lean", + "source_sha256": "2c37cf931875b93d587b43e5598f88728d7ad576a51d26101b7f4eaf567fb50c", + "object_path": "lib/lean/Lean/Server/CodeActions/Provider.olean", + "object_sha256": "b4947b1c6dc64aa327ddd9aec5ed155de2068f8d056ff0574e11d0c0c4c55a72", + "object_bytes": 616912, + "imports": [ + "Lean.Elab.BuiltinTerm", + "Lean.Elab.BuiltinNotation", + "Lean.Server.InfoUtils", + "Lean.Server.CodeActions.Attr" + ] + }, + { + "module": "Lean.Server.CodeActions", + "root": "lean", + "source_path": "src/lean/Lean/Server/CodeActions.lean", + "source_sha256": "70435662828c4e4cff20b680a501a4ff11ff83202cf68c780a45ff00ca33c807", + "object_path": "lib/lean/Lean/Server/CodeActions.olean", + "object_sha256": "df0e47bc2e8ed9a76cc9c0d3d13ecbb4bce45fed6d8eb624339267ae127f9ba9", + "object_bytes": 18112, + "imports": [ + "Lean.Server.CodeActions.Attr", + "Lean.Server.CodeActions.Basic", + "Lean.Server.CodeActions.Provider" + ] + }, + { + "module": "Lean.Server.Rpc.RequestHandling", + "root": "lean", + "source_path": "src/lean/Lean/Server/Rpc/RequestHandling.lean", + "source_sha256": "d0ad90f1cbd9a5e1b7140f4858f772a3f34ee82a447634fed67bc3ff43b52cec", + "object_path": "lib/lean/Lean/Server/Rpc/RequestHandling.olean", + "object_sha256": "c54fdbba4c0d705f4885452870f0225574487aeb0889f2e8429e583347b217ba", + "object_bytes": 568824, + "imports": [ + "Lean.Data.Lsp.Extra", + "Lean.Server.Requests", + "Lean.Server.Rpc.Basic" + ] + }, + { + "module": "Lean.Widget.UserWidget", + "root": "lean", + "source_path": "src/lean/Lean/Widget/UserWidget.lean", + "source_sha256": "74b0048825d71fbeae8f9cd81bed8ef5368e887074888067800ea00d4aa55cdf", + "object_path": "lib/lean/Lean/Widget/UserWidget.olean", + "object_sha256": "955dbc52d55b9ac29618c202f67adcb8c482bd22394d6d86c77e192f74a2886f", + "object_bytes": 1762640, + "imports": [ + "Lean.Elab.Eval", + "Lean.Server.Rpc.RequestHandling", + "Lean.Widget.Types" + ] + }, + { + "module": "Lean.Meta.Tactic.ExposeNames", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/ExposeNames.lean", + "source_sha256": "fc79b91409cf513002f2d40e9f18aa1f2a4a82166ff00b0035d4f1d7bbf299de", + "object_path": "lib/lean/Lean/Meta/Tactic/ExposeNames.olean", + "object_sha256": "b9bec235dbead6e424f288de5f73be06533f88212351293005ce739a80791895", + "object_bytes": 448840, + "imports": [ + "Lean.Meta.Tactic.Util" + ] + }, + { + "module": "Lean.Meta.TryThis", + "root": "lean", + "source_path": "src/lean/Lean/Meta/TryThis.lean", + "source_sha256": "c5ec097f30ca7416a2241a9b957a43debd38ad219036160771ff2709eb0c0549", + "object_path": "lib/lean/Lean/Meta/TryThis.olean", + "object_sha256": "14be97af5c5a37139518bc844a79f7114bed853d1e8e689b841be0aca351c968", + "object_bytes": 431216, + "imports": [ + "Lean.CoreM", + "Lean.Message", + "Lean.Elab.InfoTree.Types", + "Lean.Data.Lsp.Basic", + "Lean.PrettyPrinter" + ] + }, + { + "module": "Lean.Util.Diff", + "root": "lean", + "source_path": "src/lean/Lean/Util/Diff.lean", + "source_sha256": "ac4ae40c33a932fccf2a072936682f06ce989960cd975d6b2ba35aed535cafec", + "object_path": "lib/lean/Lean/Util/Diff.olean", + "object_sha256": "e00f75bec4db41a8570e6684672aa02b2f2c0c648c5b2115b1d45617a6d537e5", + "object_bytes": 895848, + "imports": [ + "Init.Data.Array.Subarray.Split", + "Init.Data.Range", + "Std.Data.HashMap.Basic", + "Init.Omega" + ] + }, + { + "module": "Lean.Meta.Hint", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Hint.lean", + "source_sha256": "9236600ed251df40855d972241d966d635f1ba41cafd3dd57703b6e5fc8e8dcb", + "object_path": "lib/lean/Lean/Meta/Hint.olean", + "object_sha256": "8658a16197357eb72db9aa02feb00e9c72b197e8b2d54f4483bb49fff02af3a4", + "object_bytes": 650264, + "imports": [ + "Lean.CoreM", + "Lean.Data.Lsp.Utf16", + "Lean.Message", + "Lean.Meta.TryThis", + "Lean.Util.Diff", + "Lean.Widget.Types", + "Lean.PrettyPrinter" + ] + }, + { + "module": "Lean.Meta.Tactic.TryThis", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/TryThis.lean", + "source_sha256": "dc0802ab0333b2228c9aec02f88a8c7beb44bb73ecec9bb9a617e425dcbc7e02", + "object_path": "lib/lean/Lean/Meta/Tactic/TryThis.olean", + "object_sha256": "6b804580b67f657e4a698dcf61239151afd13de196cb72ef8bf7495a0fb934bf", + "object_bytes": 1331056, + "imports": [ + "Lean.Server.CodeActions", + "Lean.Widget.UserWidget", + "Lean.Data.Json.Elab", + "Lean.Data.Lsp.Utf16", + "Lean.Meta.CollectFVars", + "Lean.Meta.Tactic.ExposeNames", + "Lean.Meta.TryThis", + "Lean.Meta.Hint" + ] + }, + { + "module": "Lean.Elab.PreDefinition.Structural.Main", + "root": "lean", + "source_path": "src/lean/Lean/Elab/PreDefinition/Structural/Main.lean", + "source_sha256": "6cc9d61c5f2cd6d33b27c548d3a4d950b6d537caae98e7536e106fe65c8cda81", + "object_path": "lib/lean/Lean/Elab/PreDefinition/Structural/Main.olean", + "object_sha256": "abf6509f2421b784a932910e87ef6451afdc05735e754ed03098056222b8b882", + "object_bytes": 1193544, + "imports": [ + "Lean.Elab.PreDefinition.TerminationMeasure", + "Lean.Elab.PreDefinition.Mutual", + "Lean.Elab.PreDefinition.Structural.Basic", + "Lean.Elab.PreDefinition.Structural.FindRecArg", + "Lean.Elab.PreDefinition.Structural.Preprocess", + "Lean.Elab.PreDefinition.Structural.BRecOn", + "Lean.Elab.PreDefinition.Structural.IndPred", + "Lean.Elab.PreDefinition.Structural.Eqns", + "Lean.Elab.PreDefinition.Structural.SmartUnfolding", + "Lean.Meta.Tactic.TryThis" + ] + }, + { + "module": "Lean.Elab.PreDefinition.Structural", + "root": "lean", + "source_path": "src/lean/Lean/Elab/PreDefinition/Structural.lean", + "source_sha256": "4391f33dd4784ced1be2a65de9d156a598d0a0566fd7650ed94a522a54a20ac7", + "object_path": "lib/lean/Lean/Elab/PreDefinition/Structural.olean", + "object_sha256": "7a869ad92fbf02c4158cf42fe27a4f30d91fa5d2fec14b8aaf659a69acf7c829", + "object_bytes": 17928, + "imports": [ + "Lean.Elab.PreDefinition.Structural.Main" + ] + }, + { + "module": "Lean.Meta.ArgsPacker.Basic", + "root": "lean", + "source_path": "src/lean/Lean/Meta/ArgsPacker/Basic.lean", + "source_sha256": "298357b9bdc438998ff6ee7f02bce1d2cbb1dd886a88a106d39c41215739d289", + "object_path": "lib/lean/Lean/Meta/ArgsPacker/Basic.olean", + "object_sha256": "2c78fb7a9953036dd8a0318f64c9bdb78b65e0c42a2a93dc642e058932125428", + "object_bytes": 45104, + "imports": [ + "Init.Data.Array.Basic" + ] + }, + { + "module": "Lean.Meta.ArgsPacker", + "root": "lean", + "source_path": "src/lean/Lean/Meta/ArgsPacker.lean", + "source_sha256": "b234970bd10785dd2d3ed5c28aef5d762c2903aeb2e813416c4d9f66c5147440", + "object_path": "lib/lean/Lean/Meta/ArgsPacker.olean", + "object_sha256": "19de8f31ef5215554384fcbd9f92306ead1daa2e0f698557283df05d552a81b2", + "object_bytes": 1259688, + "imports": [ + "Lean.Meta.AppBuilder", + "Lean.Meta.PProdN", + "Lean.Meta.ArgsPacker.Basic" + ] + }, + { + "module": "Lean.Meta.Tactic.Rewrite", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Rewrite.lean", + "source_sha256": "5360e83d477d2c298eb5081f2044e18b618ad9e40d63b287b2647fc5c8eef9b1", + "object_path": "lib/lean/Lean/Meta/Tactic/Rewrite.olean", + "object_sha256": "e5753d3da42551469cfb2a321b5cd230b55a6971ed03fa7137d4c23045e50dce", + "object_bytes": 748992, + "imports": [ + "Lean.Meta.AppBuilder", + "Lean.Meta.MatchUtil", + "Lean.Meta.KAbstract", + "Lean.Meta.Check", + "Lean.Meta.Tactic.Util", + "Lean.Meta.Tactic.Apply", + "Lean.Meta.BinderNameHint" + ] + }, + { + "module": "Lean.Elab.PreDefinition.WF.Unfold", + "root": "lean", + "source_path": "src/lean/Lean/Elab/PreDefinition/WF/Unfold.lean", + "source_sha256": "07b4648007141c304624a4ee7ae9a1d085399783de4666236430545e36956940", + "object_path": "lib/lean/Lean/Elab/PreDefinition/WF/Unfold.olean", + "object_sha256": "1e7f73a5bfe23d8ec7e1b074672f45ad0cbf77b55926cc0f7a3fbf2277c93ad6", + "object_bytes": 612424, + "imports": [ + "Lean.Elab.PreDefinition.Basic", + "Lean.Elab.PreDefinition.Eqns", + "Lean.Meta.Tactic.Apply" + ] + }, + { + "module": "Lean.Elab.PreDefinition.WF.Eqns", + "root": "lean", + "source_path": "src/lean/Lean/Elab/PreDefinition/WF/Eqns.lean", + "source_sha256": "218cff9fb9df787fc2305402fc639fbcdd23ab7dbd4b10083f31158748306a85", + "object_path": "lib/lean/Lean/Elab/PreDefinition/WF/Eqns.olean", + "object_sha256": "87c27a480959bf264cb70ed376ab916228e0ef01a7c1586274c0767d156a9993", + "object_bytes": 232656, + "imports": [ + "Lean.Meta.Tactic.Rewrite", + "Lean.Meta.Tactic.Split", + "Lean.Elab.PreDefinition.Basic", + "Lean.Elab.PreDefinition.Eqns", + "Lean.Meta.ArgsPacker.Basic", + "Lean.Elab.PreDefinition.WF.Unfold", + "Lean.Elab.PreDefinition.FixedParams", + "Init.Data.Array.Basic" + ] + }, + { + "module": "Lean.Elab.PreDefinition.WF.PackMutual", + "root": "lean", + "source_path": "src/lean/Lean/Elab/PreDefinition/WF/PackMutual.lean", + "source_sha256": "96c0f45b224ba33d89d44dd03f7bb2559da250f5a2f94e240c3e136e00ab2557", + "object_path": "lib/lean/Lean/Elab/PreDefinition/WF/PackMutual.olean", + "object_sha256": "14aeaa248d21c02cfe5be518b3db0f0625eda92555a70aa83df76e3fd7d1c74a", + "object_bytes": 436120, + "imports": [ + "Lean.Meta.ArgsPacker", + "Lean.Elab.PreDefinition.Basic", + "Lean.Elab.PreDefinition.FixedParams", + "Lean.Elab.PreDefinition.WF.Eqns" + ] + }, + { + "module": "Lean.Elab.PreDefinition.WF.FloatRecApp", + "root": "lean", + "source_path": "src/lean/Lean/Elab/PreDefinition/WF/FloatRecApp.lean", + "source_sha256": "a894135754899ff3c835f974e1f5c7e6f2a1a0aaae07095a4126f9310d975712", + "object_path": "lib/lean/Lean/Elab/PreDefinition/WF/FloatRecApp.olean", + "object_sha256": "17d93cd19d6f3c51f223c373cfd168ee2abefd2de14a59acf45e697532280737", + "object_bytes": 97488, + "imports": [ + "Lean.Meta.Transform", + "Lean.Elab.RecAppSyntax" + ] + }, + { + "module": "Lean.Meta.Tactic.Rename", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Rename.lean", + "source_sha256": "284ee66370ad14687dacc5267ef7b2c1acb879fd46d25d62e6669cc18205bac5", + "object_path": "lib/lean/Lean/Meta/Tactic/Rename.olean", + "object_sha256": "ba54ffb2e33d3e5cc0f08e1a43d21d81ab2c1a4efd564571aff7dfbba3779354", + "object_bytes": 55960, + "imports": [ + "Lean.Meta.Tactic.Util" + ] + }, + { + "module": "Lean.Elab.PreDefinition.WF.Rel", + "root": "lean", + "source_path": "src/lean/Lean/Elab/PreDefinition/WF/Rel.lean", + "source_sha256": "d64ff91247b51dbec71562a0ae8bb35d7eca7820e6d813f7de9308f71577f680", + "object_path": "lib/lean/Lean/Elab/PreDefinition/WF/Rel.olean", + "object_sha256": "223a45b52f01c7f83c23c53b921c6e3afaef92af8c4392b86a2171ea602b1b7b", + "object_bytes": 361568, + "imports": [ + "Lean.Meta.Tactic.Apply", + "Lean.Meta.Tactic.Cases", + "Lean.Meta.Tactic.Rename", + "Lean.Elab.SyntheticMVars", + "Lean.Elab.PreDefinition.Basic", + "Lean.Elab.PreDefinition.TerminationMeasure", + "Lean.Elab.PreDefinition.FixedParams", + "Lean.Meta.ArgsPacker" + ] + }, + { + "module": "Lean.Data.Array", + "root": "lean", + "source_path": "src/lean/Lean/Data/Array.lean", + "source_sha256": "d524caed4f5de05783afb14f73b6712131023327d0a4c4805880fa4ad7010310", + "object_path": "lib/lean/Lean/Data/Array.olean", + "object_sha256": "925ae22c0b68895aeda1f8300377110dbfd598bf4c26cd5e1267d8830ab7fcbf", + "object_bytes": 154648, + "imports": [ + "Init.Data.Range" + ] + }, + { + "module": "Lean.Elab.PreDefinition.WF.Basic", + "root": "lean", + "source_path": "src/lean/Lean/Elab/PreDefinition/WF/Basic.lean", + "source_sha256": "ab586c00c52ec2de91efb490b64bc91eab2220972a66ed2a5f5a248fccc67566", + "object_path": "lib/lean/Lean/Elab/PreDefinition/WF/Basic.olean", + "object_sha256": "768831ceadf5d351f9122ad18794168bd2aab789b9a0bfe8b74acf5cf111851e", + "object_bytes": 74304, + "imports": [ + "Lean.Elab.Tactic.Basic" + ] + }, + { + "module": "Lean.Meta.Tactic.Cleanup", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Cleanup.lean", + "source_sha256": "0e6b5bf7a820ff8b02b2ecdeec8e245f5cb07a6c31fd98943f681cb049a59398", + "object_path": "lib/lean/Lean/Meta/Tactic/Cleanup.olean", + "object_sha256": "8e573cac3f9ebb27395fc6cd379d87a1570f8bccef8a8a02417c5d18d40458b3", + "object_bytes": 398944, + "imports": [ + "Lean.Meta.CollectFVars", + "Lean.Meta.Tactic.Clear" + ] + }, + { + "module": "Lean.Elab.PreDefinition.WF.Fix", + "root": "lean", + "source_path": "src/lean/Lean/Elab/PreDefinition/WF/Fix.lean", + "source_sha256": "4490ca054492e62641c079307d02be51fe92b2432a779fd709339d16c391e3fa", + "object_path": "lib/lean/Lean/Elab/PreDefinition/WF/Fix.olean", + "object_sha256": "49fcf7d82954b74334d6cb0f811e9a0984337c7ce8699925dc6bda4cb6c6eba8", + "object_bytes": 1585568, + "imports": [ + "Lean.Data.Array", + "Lean.Elab.PreDefinition.Basic", + "Lean.Elab.PreDefinition.WF.Basic", + "Lean.Elab.Tactic.Basic", + "Lean.Meta.ArgsPacker", + "Lean.Meta.ForEachExpr", + "Lean.Meta.Match.MatcherApp.Transform", + "Lean.Meta.Tactic.Cleanup", + "Lean.Util.HasConstCache" + ] + }, + { + "module": "Lean.Meta.Tactic.Simp.SimpAll", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Simp/SimpAll.lean", + "source_sha256": "0a1feb877019672b16496e0b24bb029295efe594bf92d1566e5624834905b50d", + "object_path": "lib/lean/Lean/Meta/Tactic/Simp/SimpAll.olean", + "object_sha256": "19742f76f5da7f84bfcbb77c29b94a2c29c3ff8fce6e91dda0ad8d00044d3fae", + "object_bytes": 687744, + "imports": [ + "Lean.Meta.Tactic.Clear", + "Lean.Meta.Tactic.Util", + "Lean.Meta.Tactic.Simp.Main" + ] + }, + { + "module": "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Core", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Core.lean", + "source_sha256": "4d3dc20e370977db427ae74f2393b46479c89a50068cdb5546944e7d4a2583ef", + "object_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Core.olean", + "object_sha256": "096d4b309441f49bc8b361417ba9c755c39075f2f13ed9cdcfdb2690494d0ecb", + "object_bytes": 447440, + "imports": [ + "Init.Simproc", + "Lean.Meta.Tactic.Simp.Simproc" + ] + }, + { + "module": "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Util", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Util.lean", + "source_sha256": "ec12a9437e418d031310cc54ab510c34b86a78f2d68c94ec452bf9cb0bf46bce", + "object_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Util.olean", + "object_sha256": "f25c7d6ffbe08cf2e9bb4892984a1cb2589b87866a4673b8ae469eccc5747d0a", + "object_bytes": 73400, + "imports": [ + "Lean.Meta.Tactic.Simp.Simproc" + ] + }, + { + "module": "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Nat.lean", + "source_sha256": "3f5242bbc37015bd2b92e8ca6a1688b543950cb41c21e53d76d035ed637b8fe5", + "object_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Nat.olean", + "object_sha256": "149b340c172d133f8ed39eda036901e8d0b1f3eb665bd532cf2898ea2ded506c", + "object_bytes": 1313328, + "imports": [ + "Init.Simproc", + "Init.Data.Nat.Simproc", + "Lean.Util.SafeExponentiation", + "Lean.Meta.LitValues", + "Lean.Meta.Offset", + "Lean.Meta.Tactic.Simp.Simproc", + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Util" + ] + }, + { + "module": "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Fin.lean", + "source_sha256": "9eb2cd13dcbb2c7a8f951c007ded592081959a9ac966236bd23c81e51d147817", + "object_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Fin.olean", + "object_sha256": "87b1648e2127933ccd8a79e0dbde8d3368f9197735af402f261a14fb01a7130a", + "object_bytes": 1175656, + "imports": [ + "Lean.ToExpr", + "Lean.Meta.LitValues", + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat" + ] + }, + { + "module": "Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/UInt.lean", + "source_sha256": "f678bb2201b695b328e2f0bcb8e7816b45c395baa6dcbe1213db68cee1f87ec5", + "object_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/UInt.olean", + "object_sha256": "f411c05e1e3e750eacf2d9085324aa9f5ccf3f54cf2807a7d3644d5641d0c54e", + "object_bytes": 2635808, + "imports": [ + "Lean.Meta.LitValues", + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat" + ] + }, + { + "module": "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Int.lean", + "source_sha256": "df096c50dc5806fbb5ed99db60f0cdbb2bf95c6eb6d7a87c6e39db92d91c2074", + "object_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Int.olean", + "object_sha256": "3454358f8c0e57fd441607ebe196e24e87f6feb8d8fdb6285324b0d456073896", + "object_bytes": 901312, + "imports": [ + "Lean.ToExpr", + "Lean.Meta.LitValues", + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat" + ] + }, + { + "module": "Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/SInt.lean", + "source_sha256": "de3c1d413678fc15ae019d2308d490ac6e3a5c2927098e0402bcf4e22c359af6", + "object_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/SInt.olean", + "object_sha256": "563a81b80c8763959834f9ed1305928da53f70a494ba7dee05ea56db5c21feeb", + "object_bytes": 3324728, + "imports": [ + "Lean.Meta.LitValues", + "Init.Data.SInt.Lemmas", + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat", + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int" + ] + }, + { + "module": "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Char.lean", + "source_sha256": "31df486258d6ef50a59e0b8594a6246d2520e58b3da89c381ea9fd7ba3be81e1", + "object_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Char.olean", + "object_sha256": "bcc885c5416084df7a7ff67147d681a82d039a53e65395c847f53df75653031c", + "object_bytes": 626408, + "imports": [ + "Lean.ToExpr", + "Lean.Meta.LitValues", + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt" + ] + }, + { + "module": "Lean.Meta.Tactic.Simp.BuiltinSimprocs.String", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/String.lean", + "source_sha256": "01f68d42399de9f39016f9fb2a0041a47337bad804a0fe3171aee056572ead62", + "object_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/String.olean", + "object_sha256": "b5f395acbfde95a4537ab207fc8353feb4ea44b5c031704ac6646ae96abd772e", + "object_bytes": 321280, + "imports": [ + "Lean.ToExpr", + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char" + ] + }, + { + "module": "Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/BitVec.lean", + "source_sha256": "95f58d7c977e921587fdb7a90dd12fe6afcb6f30bcd625bbefd124adcaf34dc2", + "object_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/BitVec.olean", + "object_sha256": "85aed4f46b983f8689fb18c2a56f455f7789bf7753716509470208bdbe3f5171", + "object_bytes": 1805336, + "imports": [ + "Lean.Meta.LitValues", + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat", + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int", + "Init.Data.BitVec.Basic", + "Init.Data.BitVec.Lemmas" + ] + }, + { + "module": "Lean.Meta.Tactic.Simp.BuiltinSimprocs.List", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/List.lean", + "source_sha256": "05147186f211a04f51cef55c4e082ab894fed2d34c907216d8c43096c003177f", + "object_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/List.olean", + "object_sha256": "75879a5bc624a4924f6b1550e568328a8d65d28fc0127ce2aebc9a79b32c247e", + "object_bytes": 93272, + "imports": [ + "Lean.Meta.LitValues", + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat" + ] + }, + { + "module": "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Array", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Array.lean", + "source_sha256": "51786cb0d6456056fc1006b79534261f90c29dc19e3ff5b19ca34db53ec6302e", + "object_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Array.olean", + "object_sha256": "bb9d2451f7b1ef51ee371c4f0d427f03a4b2f46e5052f3f6e2268712203ffd7f", + "object_bytes": 221856, + "imports": [ + "Lean.Meta.LitValues", + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat" + ] + }, + { + "module": "Lean.Meta.Tactic.Simp.BuiltinSimprocs", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs.lean", + "source_sha256": "146ab4ea5a360338ffb2ca18f69650aad54bd72a8789c13236fa6ca4b291aa21", + "object_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs.olean", + "object_sha256": "db1b01c3d3a3331c043eff98ba15a304519219ce3d330483744e4af291eac724", + "object_bytes": 19000, + "imports": [ + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Core", + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat", + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin", + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt", + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt", + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int", + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char", + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.String", + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec", + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.List", + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Array" + ] + }, + { + "module": "Lean.Meta.Tactic.Simp", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Simp.lean", + "source_sha256": "428ebabfe005b70d9b58fd0098de76e1b9d96860ccda88ffc2444de438841329", + "object_path": "lib/lean/Lean/Meta/Tactic/Simp.olean", + "object_sha256": "cec02bc00ad6401bc1ef173de50c764540b40f87be56136e0d758e8e1f2251a5", + "object_bytes": 74552, + "imports": [ + "Lean.Meta.Tactic.Simp.SimpTheorems", + "Lean.Meta.Tactic.Simp.SimpCongrTheorems", + "Lean.Meta.Tactic.Simp.Types", + "Lean.Meta.Tactic.Simp.Main", + "Lean.Meta.Tactic.Simp.Rewrite", + "Lean.Meta.Tactic.Simp.SimpAll", + "Lean.Meta.Tactic.Simp.Simproc", + "Lean.Meta.Tactic.Simp.BuiltinSimprocs", + "Lean.Meta.Tactic.Simp.RegisterCommand", + "Lean.Meta.Tactic.Simp.Attr", + "Lean.Meta.Tactic.Simp.Diagnostics", + "Lean.Meta.Tactic.Simp.Arith" + ] + }, + { + "module": "Lean.Elab.Tactic.Config", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/Config.lean", + "source_sha256": "6d75bbf0a3e173851aa999e9c5cfc25cbfca8e53b0632cbf7f7281ae3847dccd", + "object_path": "lib/lean/Lean/Elab/Tactic/Config.olean", + "object_sha256": "9610894e2849bdc2cc085f7a96639f6520f84c49d0e485133e7b3f9906dfd64d", + "object_bytes": 1379600, + "imports": [ + "Lean.Meta.Eval", + "Lean.Elab.Tactic.Basic", + "Lean.Elab.SyntheticMVars", + "Lean.Linter.MissingDocs" + ] + }, + { + "module": "Lean.Elab.Tactic.ElabTerm", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/ElabTerm.lean", + "source_sha256": "a73ff4218da2dabca6ea97059da285bfdbbfd10a4a98d5e042266c0fd5a49082", + "object_path": "lib/lean/Lean/Elab/Tactic/ElabTerm.olean", + "object_sha256": "16d425f224d94ced7be01601700ab5b4868a108cd69d4e717aff9d50c9072d24", + "object_bytes": 2026952, + "imports": [ + "Lean.Meta.Tactic.Constructor", + "Lean.Meta.Tactic.Assert", + "Lean.Meta.Tactic.AuxLemma", + "Lean.Meta.Tactic.Cleanup", + "Lean.Meta.Tactic.Clear", + "Lean.Meta.Tactic.Rename", + "Lean.Elab.Tactic.Basic", + "Lean.Elab.Tactic.Config", + "Lean.Elab.SyntheticMVars" + ] + }, + { + "module": "Lean.Elab.Tactic.Location", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/Location.lean", + "source_sha256": "921745ad88bf1e77fdbb1644642537f58452422592225a15efe0ec4cc2a0f89d", + "object_path": "lib/lean/Lean/Elab/Tactic/Location.olean", + "object_sha256": "7e5a06249e3737e4deba34697796e2da2fe1688af242fdfab61992b15fe66427", + "object_bytes": 217848, + "imports": [ + "Lean.Elab.Tactic.Basic", + "Lean.Elab.Tactic.ElabTerm" + ] + }, + { + "module": "Lean.Elab.Tactic.Simp", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/Simp.lean", + "source_sha256": "60f3bb1c5e71e352718498e5b50f8322213d8fe6f0b7d4b87efe3ae34e616a7d", + "object_path": "lib/lean/Lean/Elab/Tactic/Simp.olean", + "object_sha256": "27dd904434ea0a6b3cd00758863a740948fbdb491d261ceb6a4dcf4f985bab0c", + "object_bytes": 2080184, + "imports": [ + "Lean.Meta.Tactic.Simp", + "Lean.Meta.Tactic.Replace", + "Lean.Elab.BuiltinNotation", + "Lean.Elab.Tactic.Basic", + "Lean.Elab.Tactic.ElabTerm", + "Lean.Elab.Tactic.Location", + "Lean.Elab.Tactic.Config" + ] + }, + { + "module": "Lean.Elab.PreDefinition.WF.Preprocess", + "root": "lean", + "source_path": "src/lean/Lean/Elab/PreDefinition/WF/Preprocess.lean", + "source_sha256": "ed13945651f7f3dfd4ebfa46874f5d69f15224e4cb02dac76c790bf05d06dae1", + "object_path": "lib/lean/Lean/Elab/PreDefinition/WF/Preprocess.olean", + "object_sha256": "a4f8e969990723a1ffc73c041430a5d85622e9ba8505d3a9db658518448d1759", + "object_bytes": 553408, + "imports": [ + "Lean.Meta.Transform", + "Lean.Meta.Match.MatcherApp.Basic", + "Lean.Elab.Tactic.Simp" + ] + }, + { + "module": "Lean.Elab.Quotation", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Quotation.lean", + "source_sha256": "a89098bf74731da881b1b83bfac0395b4c20788a50a03d97cf9fd2a1d2bd8340", + "object_path": "lib/lean/Lean/Elab/Quotation.olean", + "object_sha256": "89273b9bed7b0bdeb17d2c68444e7bbde5e2b75bf7560ba8bcde99255511cc86", + "object_bytes": 4759904, + "imports": [ + "Lean.Syntax", + "Lean.ResolveName", + "Lean.Elab.Term", + "Lean.Elab.Quotation.Util", + "Lean.Elab.Quotation.Precheck", + "Lean.Elab.Syntax", + "Lean.Parser.Syntax" + ] + }, + { + "module": "Lean.Elab.PreDefinition.WF.GuessLex", + "root": "lean", + "source_path": "src/lean/Lean/Elab/PreDefinition/WF/GuessLex.lean", + "source_sha256": "9b5e4397a7c0da7fbc47774fb3430502b69481b596b7fa44af9a6b11abd1be6e", + "object_path": "lib/lean/Lean/Elab/PreDefinition/WF/GuessLex.olean", + "object_sha256": "9cace92578ca748974c695adfe3b2ff55ec2099a67756a816c700c28c161f1fb", + "object_bytes": 2896936, + "imports": [ + "Lean.Util.HasConstCache", + "Lean.Meta.Match.MatcherApp.Transform", + "Lean.Meta.Tactic.Cleanup", + "Lean.Meta.Tactic.Refl", + "Lean.Meta.Tactic.TryThis", + "Lean.Meta.ArgsPacker", + "Lean.Elab.Quotation", + "Lean.Elab.RecAppSyntax", + "Lean.Elab.PreDefinition.Basic", + "Lean.Elab.PreDefinition.Mutual", + "Lean.Elab.PreDefinition.Structural.Basic", + "Lean.Elab.PreDefinition.TerminationMeasure", + "Lean.Elab.PreDefinition.FixedParams", + "Lean.Elab.PreDefinition.WF.Basic", + "Lean.Data.Array" + ] + }, + { + "module": "Lean.Elab.PreDefinition.WF.Main", + "root": "lean", + "source_path": "src/lean/Lean/Elab/PreDefinition/WF/Main.lean", + "source_sha256": "a68ec62259857e0509b783745904e2bf04f4b864198a1e0147f6ee281f69c0a4", + "object_path": "lib/lean/Lean/Elab/PreDefinition/WF/Main.olean", + "object_sha256": "127ec7d6c1f12197bb0dfdfcb047a889c49fbea1bf2757ede5f98f17fbdd2797", + "object_bytes": 501784, + "imports": [ + "Lean.Elab.PreDefinition.Basic", + "Lean.Elab.PreDefinition.TerminationMeasure", + "Lean.Elab.PreDefinition.Mutual", + "Lean.Elab.PreDefinition.WF.PackMutual", + "Lean.Elab.PreDefinition.WF.FloatRecApp", + "Lean.Elab.PreDefinition.WF.Rel", + "Lean.Elab.PreDefinition.WF.Fix", + "Lean.Elab.PreDefinition.WF.Unfold", + "Lean.Elab.PreDefinition.WF.Preprocess", + "Lean.Elab.PreDefinition.WF.GuessLex" + ] + }, + { + "module": "Lean.Elab.PreDefinition.MkInhabitant", + "root": "lean", + "source_path": "src/lean/Lean/Elab/PreDefinition/MkInhabitant.lean", + "source_sha256": "8f85f3704ed7853965888a423810ad3cfc538277c9bdfece160b8e4fc21ed6cc", + "object_path": "lib/lean/Lean/Elab/PreDefinition/MkInhabitant.olean", + "object_sha256": "1bc6102c2d1165d8dd1c485863817fdee1b6434e48323774dec026c1e6d58143", + "object_bytes": 273640, + "imports": [ + "Lean.Meta.AppBuilder", + "Lean.PrettyPrinter" + ] + }, + { + "module": "Lean.Elab.Tactic.BuiltinTactic", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/BuiltinTactic.lean", + "source_sha256": "0061ad22cb89abd2de189c7a69ba987a7672d183e618b33ff4818439efedffdc", + "object_path": "lib/lean/Lean/Elab/Tactic/BuiltinTactic.olean", + "object_sha256": "87508f95948aa59eed04caad479482d5bdac0599fcbd68ef1681cdcdd590173c", + "object_bytes": 3991920, + "imports": [ + "Lean.Meta.Diagnostics", + "Lean.Meta.Tactic.Apply", + "Lean.Meta.Tactic.Assumption", + "Lean.Meta.Tactic.Contradiction", + "Lean.Meta.Tactic.Refl", + "Lean.Elab.Binders", + "Lean.Elab.Open", + "Lean.Elab.Eval", + "Lean.Elab.SetOption", + "Lean.Elab.Tactic.Basic", + "Lean.Elab.Tactic.ElabTerm", + "Lean.Elab.Do" + ] + }, + { + "module": "Lean.Elab.Tactic.Conv.Basic", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/Conv/Basic.lean", + "source_sha256": "942d86c5086c4346616b19d9e1647fbb20f0c31e059f7b6db421652c8dfe161a", + "object_path": "lib/lean/Lean/Elab/Tactic/Conv/Basic.olean", + "object_sha256": "d9f767b8d2827e59684a796b11bc48ac8760b6a66225e8dd4248f676bf144ca1", + "object_bytes": 842192, + "imports": [ + "Lean.Meta.Reduce", + "Lean.Meta.Tactic.Apply", + "Lean.Meta.Tactic.Replace", + "Lean.Elab.Tactic.Basic", + "Lean.Elab.Tactic.BuiltinTactic" + ] + }, + { + "module": "Lean.Meta.Tactic.Congr", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Congr.lean", + "source_sha256": "51519d7233d1891c43d3b623cb77aa4a3e317ed859483fd4cfaf4aa5701a2b9e", + "object_path": "lib/lean/Lean/Meta/Tactic/Congr.olean", + "object_sha256": "9699d92b8fad21a10f6d3cadd3bc06b1029411d37475a9da68a2cc58fc1a1950", + "object_bytes": 351648, + "imports": [ + "Lean.Meta.CongrTheorems", + "Lean.Meta.Tactic.Assert", + "Lean.Meta.Tactic.Apply", + "Lean.Meta.Tactic.Clear", + "Lean.Meta.Tactic.Refl", + "Lean.Meta.Tactic.Assumption" + ] + }, + { + "module": "Lean.Elab.Tactic.Conv.Congr", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/Conv/Congr.lean", + "source_sha256": "28cceaf7eb47ff68193eef87cfea9541bacf1d26395da33dbbd6db6efed6713c", + "object_path": "lib/lean/Lean/Elab/Tactic/Conv/Congr.olean", + "object_sha256": "407773161e1ca9bcc180752d9998d413fdf42e65ea0b606c49d4f89274a14786", + "object_bytes": 1967016, + "imports": [ + "Lean.Meta.Tactic.Simp.Main", + "Lean.Meta.Tactic.Congr", + "Lean.Elab.Tactic.Conv.Basic" + ] + }, + { + "module": "Lean.Elab.Tactic.Rewrite", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/Rewrite.lean", + "source_sha256": "5176f2be4538fdb3054529ad8735a770a31b55b0dafcd001b586421cf45a00f1", + "object_path": "lib/lean/Lean/Elab/Tactic/Rewrite.olean", + "object_sha256": "98c92aed4731bb529a41fc20ddb00009a0ca59200db0120cc3c5bda3087e3eff", + "object_bytes": 541656, + "imports": [ + "Lean.Meta.Tactic.Rewrite", + "Lean.Meta.Tactic.Replace", + "Lean.Elab.Tactic.Location", + "Lean.Elab.Tactic.Config" + ] + }, + { + "module": "Lean.Elab.Tactic.Conv.Rewrite", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/Conv/Rewrite.lean", + "source_sha256": "5c3bc59731aa52426c077b6eaf4d6cc6eff571d724e4a4df37dcc89ab653f640", + "object_path": "lib/lean/Lean/Elab/Tactic/Conv/Rewrite.olean", + "object_sha256": "1b255dabe387aabea64c6a8df3fcc6ac652b132b2a6f8326c8671176ea9c8b76", + "object_bytes": 90064, + "imports": [ + "Lean.Meta.Tactic.Rewrite", + "Lean.Elab.Tactic.Rewrite", + "Lean.Elab.Tactic.Conv.Basic" + ] + }, + { + "module": "Lean.Elab.Tactic.Change", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/Change.lean", + "source_sha256": "9611281f63b5b8515ee68a05924e9cdd68bed404bf0a770d5c537a61cb6c71a2", + "object_path": "lib/lean/Lean/Elab/Tactic/Change.olean", + "object_sha256": "2f28897596af8790185d23dd1909f93cbffbdbeecdd6d6fd11e0846743d0d2ed", + "object_bytes": 262064, + "imports": [ + "Lean.Meta.Tactic.Replace", + "Lean.Elab.Tactic.Location" + ] + }, + { + "module": "Lean.Elab.Tactic.Conv.Change", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/Conv/Change.lean", + "source_sha256": "d4728a69635e06cd8a6d5de1bb500dc3f36c0250c81ce95c3f89fc18bb1857fb", + "object_path": "lib/lean/Lean/Elab/Tactic/Conv/Change.olean", + "object_sha256": "d265e56036b5206494c997587dc53dc6fbc552f7b9eeec986dd5155c971c9756", + "object_bytes": 82784, + "imports": [ + "Lean.Elab.Tactic.ElabTerm", + "Lean.Elab.Tactic.Change", + "Lean.Elab.Tactic.Conv.Basic" + ] + }, + { + "module": "Lean.Meta.Tactic.Lets", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Lets.lean", + "source_sha256": "79544763294742cb5195afc0a5515185484eddd039f6bdfad415a71d48e19054", + "object_path": "lib/lean/Lean/Meta/Tactic/Lets.olean", + "object_sha256": "7dec9ce2a1f04a1da691832884b2b6b57a56a9fce979d8c07ae3a4c3849216df", + "object_bytes": 1411864, + "imports": [ + "Lean.Meta.Tactic.Replace" + ] + }, + { + "module": "Lean.Elab.Tactic.Lets", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/Lets.lean", + "source_sha256": "9a716ae497a8855cea6f8a483d417295ed7610c2caba9da187db57507c5230eb", + "object_path": "lib/lean/Lean/Elab/Tactic/Lets.olean", + "object_sha256": "c2ab93d529041eadc4eb36961cbb2b5f972c882600d913bcbe1c78906edd5858", + "object_bytes": 506944, + "imports": [ + "Lean.Meta.Tactic.Lets", + "Lean.Elab.Tactic.Location" + ] + }, + { + "module": "Lean.Elab.Tactic.Conv.Lets", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/Conv/Lets.lean", + "source_sha256": "e75064ef07cf870121e25cea31b212df1331c146bce939f80ed50bec51d7199f", + "object_path": "lib/lean/Lean/Elab/Tactic/Conv/Lets.olean", + "object_sha256": "403736a52ada9ac333480b7d103bceb23d51c130ce97373654b767e67ec2fb96", + "object_bytes": 221128, + "imports": [ + "Lean.Elab.Tactic.Lets", + "Lean.Elab.Tactic.Conv.Basic" + ] + }, + { + "module": "Lean.Elab.Tactic.Split", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/Split.lean", + "source_sha256": "107ab6e6b0fa7af9c154b03aa4e65f4ffa8b5c7d81252a86e1980726834f5e05", + "object_path": "lib/lean/Lean/Elab/Tactic/Split.olean", + "object_sha256": "b605d212c08606891689f48aa8ae766b76b5f1cebe95d2b56855b9594f0a1837", + "object_bytes": 198840, + "imports": [ + "Lean.Meta.Tactic.Split", + "Lean.Elab.Tactic.Basic", + "Lean.Elab.Tactic.Location" + ] + }, + { + "module": "Lean.Elab.AuxDef", + "root": "lean", + "source_path": "src/lean/Lean/Elab/AuxDef.lean", + "source_sha256": "8301be27595dd1eedb37138ae2cbc3346b0f621e96c43085b7d3d9e01c52da86", + "object_path": "lib/lean/Lean/Elab/AuxDef.olean", + "object_sha256": "74da58d581d71ca405d8a14308a4e9cf3ddebfd9a5a3ec1160090f280af94720", + "object_bytes": 260944, + "imports": [ + "Lean.Elab.Command" + ] + }, + { + "module": "Lean.Elab.ElabRules", + "root": "lean", + "source_path": "src/lean/Lean/Elab/ElabRules.lean", + "source_sha256": "16b40b59ab7b50290895adf303f80c8299094f14cb0d7bb71a61d84765ac382b", + "object_path": "lib/lean/Lean/Elab/ElabRules.olean", + "object_sha256": "931427b5e67c0b3a778b3249b86aebab1ca1e895e64d288c689da4c3e7cb649e", + "object_bytes": 1056016, + "imports": [ + "Lean.Elab.MacroArgUtil", + "Lean.Elab.AuxDef" + ] + }, + { + "module": "Lean.Elab.Tactic.SimpTrace", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/SimpTrace.lean", + "source_sha256": "e7e8975de7b9a1dc613069bdaca9fc00af3b56ffb202e06413380742414ecdd9", + "object_path": "lib/lean/Lean/Elab/Tactic/SimpTrace.olean", + "object_sha256": "50c1884dfdac951c465d1acdbdfeccc3329d6c82d35b7e02cedc435069497777", + "object_bytes": 658944, + "imports": [ + "Lean.Elab.ElabRules", + "Lean.Elab.Tactic.Simp", + "Lean.Meta.Tactic.TryThis" + ] + }, + { + "module": "Lean.Elab.Tactic.Conv.Simp", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/Conv/Simp.lean", + "source_sha256": "edfa5d7b725aa86ca4ea5229d820d94679a2beb03e98b53bcdf5831e0a9ed302", + "object_path": "lib/lean/Lean/Elab/Tactic/Conv/Simp.olean", + "object_sha256": "87d03c95513fb20acaf7354771c184a43fc1bdfe6276094ac1f06c196c012567", + "object_bytes": 402360, + "imports": [ + "Lean.Elab.Tactic.Simp", + "Lean.Elab.Tactic.Split", + "Lean.Elab.Tactic.Conv.Basic", + "Lean.Elab.Tactic.SimpTrace" + ] + }, + { + "module": "Lean.Elab.Tactic.Conv.Pattern", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/Conv/Pattern.lean", + "source_sha256": "20c459dd6dea290054941b09723e842fb4b64fadb563fbc377eeec4d3ec79598", + "object_path": "lib/lean/Lean/Elab/Tactic/Conv/Pattern.olean", + "object_sha256": "a2b845b9155a9f365d2c29d58f34b2d0f582205d8f7b551676e65dd797ff5ba8", + "object_bytes": 650712, + "imports": [ + "Lean.Elab.Tactic.Simp", + "Lean.Elab.Tactic.Conv.Basic", + "Lean.HeadIndex" + ] + }, + { + "module": "Lean.Elab.Tactic.Delta", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/Delta.lean", + "source_sha256": "a96954d8614b4116ba8ea51543a9ec4732952e551e8d3edeffdc168b631940f0", + "object_path": "lib/lean/Lean/Elab/Tactic/Delta.olean", + "object_sha256": "fd4e9e9632c5041922c0a5e64028fae427712267bc9677be391ea15c4eb1bca4", + "object_bytes": 146920, + "imports": [ + "Lean.Meta.Tactic.Delta", + "Lean.Elab.Tactic.Basic", + "Lean.Elab.Tactic.Location" + ] + }, + { + "module": "Lean.Elab.Tactic.Conv.Delta", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/Conv/Delta.lean", + "source_sha256": "187728c42a564f61094e1f26a5df8b332f0d1211c92bf5722fc89070bf206b0a", + "object_path": "lib/lean/Lean/Elab/Tactic/Conv/Delta.olean", + "object_sha256": "0f0a781814f456349a449a940ce9f8c3cf67546fd5ade5fce81ccf9be6932125", + "object_bytes": 76864, + "imports": [ + "Lean.Elab.Tactic.Delta", + "Lean.Elab.Tactic.Conv.Basic" + ] + }, + { + "module": "Lean.Meta.Tactic.Unfold", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Unfold.lean", + "source_sha256": "77517077705bdb2a46aaf020df53199ee33b3a41fcda1857fcc423699c2b3ae3", + "object_path": "lib/lean/Lean/Meta/Tactic/Unfold.olean", + "object_sha256": "050361b7f6f66a6ef0c9b3f36fc3ad295566da9b50f6b74601b2d42cecf72e36", + "object_bytes": 290376, + "imports": [ + "Lean.Meta.Eqns", + "Lean.Meta.Tactic.Delta", + "Lean.Meta.Tactic.Simp.Main" + ] + }, + { + "module": "Lean.Elab.Tactic.Unfold", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/Unfold.lean", + "source_sha256": "8234b9dd6be3f6b9cdd1abe49086ddbc0388a4d92371c73f668d4a7ef3e16db2", + "object_path": "lib/lean/Lean/Elab/Tactic/Unfold.olean", + "object_sha256": "2e56ecb7917921d3e6da807a3d87cb8d920a8eac2672eba40e24e83d4617231d", + "object_bytes": 233584, + "imports": [ + "Lean.Meta.Tactic.Unfold", + "Lean.Elab.Tactic.Basic", + "Lean.Elab.Tactic.Location" + ] + }, + { + "module": "Lean.Elab.Tactic.Conv.Unfold", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/Conv/Unfold.lean", + "source_sha256": "c7ee5cb46447ca260384fff8e8281cea164924ce31adf61f7b3d425723095509", + "object_path": "lib/lean/Lean/Elab/Tactic/Conv/Unfold.olean", + "object_sha256": "6e4054e184a583f36d45120e253670220bf84dc0c4eea59e4faa59281440e77f", + "object_bytes": 225376, + "imports": [ + "Lean.Elab.Tactic.Unfold", + "Lean.Elab.Tactic.Conv.Simp" + ] + }, + { + "module": "Lean.Elab.Tactic.Conv", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/Conv.lean", + "source_sha256": "9802af8b10f5ef5c70b9c2577b087d0540c9ecf748212f6821398802e7c09493", + "object_path": "lib/lean/Lean/Elab/Tactic/Conv.olean", + "object_sha256": "02d57d92ee107ca453a1a5504bd0729183019cb39973573af31ff1b43e1bba55", + "object_bytes": 18680, + "imports": [ + "Lean.Elab.Tactic.Conv.Basic", + "Lean.Elab.Tactic.Conv.Congr", + "Lean.Elab.Tactic.Conv.Rewrite", + "Lean.Elab.Tactic.Conv.Change", + "Lean.Elab.Tactic.Conv.Lets", + "Lean.Elab.Tactic.Conv.Simp", + "Lean.Elab.Tactic.Conv.Pattern", + "Lean.Elab.Tactic.Conv.Delta", + "Lean.Elab.Tactic.Conv.Unfold" + ] + }, + { + "module": "Lean.Elab.PreDefinition.PartialFixpoint.Eqns", + "root": "lean", + "source_path": "src/lean/Lean/Elab/PreDefinition/PartialFixpoint/Eqns.lean", + "source_sha256": "fd1b456adde9603a6e8bd5596b57a6696d8373753e14acc212586a874c199cff", + "object_path": "lib/lean/Lean/Elab/PreDefinition/PartialFixpoint/Eqns.olean", + "object_sha256": "df3704806488ffd73b370522fd82e7cdc2de8a85b1ff2961febf347af5701185", + "object_bytes": 615216, + "imports": [ + "Lean.Elab.Tactic.Conv", + "Lean.Meta.Tactic.Rewrite", + "Lean.Meta.Tactic.Split", + "Lean.Elab.PreDefinition.Basic", + "Lean.Elab.PreDefinition.Eqns", + "Lean.Elab.PreDefinition.FixedParams", + "Lean.Meta.ArgsPacker.Basic", + "Init.Data.Array.Basic", + "Init.Internal.Order.Basic" + ] + }, + { + "module": "Lean.Elab.Tactic.Monotonicity", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/Monotonicity.lean", + "source_sha256": "693396cb1d2df96333ab76920907716cbdb6b074b5ea5ac58b043c40b8a70492", + "object_path": "lib/lean/Lean/Elab/Tactic/Monotonicity.olean", + "object_sha256": "99f6c5c1bbc688982bd4dea59274b662a7670b6f2faed19266aa128c52d8342e", + "object_bytes": 1231728, + "imports": [ + "Lean.Meta.Tactic.Split", + "Lean.Elab.RecAppSyntax", + "Lean.Elab.Tactic.Basic", + "Init.Internal.Order" + ] + }, + { + "module": "Lean.Meta.Order", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Order.lean", + "source_sha256": "338ad306cb715c7eb75635614768a90c0f6b46bf53593a1d16d99c8dd2e2e79f", + "object_path": "lib/lean/Lean/Meta/Order.olean", + "object_sha256": "10cd1fdeb63ddb4a0127b8d753e038a95108316a435d4290e0c497a68732f4f5", + "object_bytes": 169592, + "imports": [ + "Lean.Meta.InferType", + "Lean.Meta.PProdN", + "Lean.Meta.AppBuilder", + "Init.Internal.Order.Basic" + ] + }, + { + "module": "Lean.Elab.PreDefinition.PartialFixpoint.Main", + "root": "lean", + "source_path": "src/lean/Lean/Elab/PreDefinition/PartialFixpoint/Main.lean", + "source_sha256": "444b61efbe51624920de82c40cbace7d1b3d7ebcd7cc87a1a8bfc743931e75ba", + "object_path": "lib/lean/Lean/Elab/PreDefinition/PartialFixpoint/Main.olean", + "object_sha256": "2732cf2ffd98405a0b4fb2954f3a8e427bb2ff2ecfe939baeca4d7adae5acd48", + "object_bytes": 902488, + "imports": [ + "Lean.Elab.PreDefinition.MkInhabitant", + "Lean.Elab.PreDefinition.Mutual", + "Lean.Elab.PreDefinition.PartialFixpoint.Eqns", + "Lean.Elab.Tactic.Monotonicity", + "Init.Internal.Order.Basic", + "Lean.Meta.PProdN", + "Lean.Meta.Order" + ] + }, + { + "module": "Lean.Meta.Injective", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Injective.lean", + "source_sha256": "608f6648cabfa21de7000942fae99e82e2a01db19f3abb52fec27997263071cd", + "object_path": "lib/lean/Lean/Meta/Injective.olean", + "object_sha256": "1401edb00f13f1842983eaf1f193091264e83b81e9ac2f8d7e252154653ba1cd", + "object_bytes": 775888, + "imports": [ + "Lean.Meta.Transform", + "Lean.Meta.Tactic.Injection", + "Lean.Meta.Tactic.Apply", + "Lean.Meta.Tactic.Refl", + "Lean.Meta.Tactic.Cases", + "Lean.Meta.Tactic.Subst", + "Lean.Meta.Tactic.Simp.Types", + "Lean.Meta.Tactic.Assumption" + ] + }, + { + "module": "Lean.Elab.PreDefinition.PartialFixpoint.Induction", + "root": "lean", + "source_path": "src/lean/Lean/Elab/PreDefinition/PartialFixpoint/Induction.lean", + "source_sha256": "54c0fdb18c31511bdd207196a4c73d846ff1e24d2f06da3cc4742bc00529ae7e", + "object_path": "lib/lean/Lean/Elab/PreDefinition/PartialFixpoint/Induction.olean", + "object_sha256": "8f776f609c13b2a226b904ae40f29071ef37e75f998785c8579e619d431aa43f", + "object_bytes": 1348040, + "imports": [ + "Lean.Meta.Basic", + "Lean.Meta.Match.MatcherApp.Transform", + "Lean.Meta.Check", + "Lean.Meta.Tactic.Subst", + "Lean.Meta.Injective", + "Lean.Meta.ArgsPacker", + "Lean.Meta.PProdN", + "Lean.Meta.Tactic.Apply", + "Lean.Elab.PreDefinition.PartialFixpoint.Eqns", + "Lean.Elab.Command", + "Lean.Meta.Tactic.ElimInfo" + ] + }, + { + "module": "Lean.Elab.PreDefinition.PartialFixpoint", + "root": "lean", + "source_path": "src/lean/Lean/Elab/PreDefinition/PartialFixpoint.lean", + "source_sha256": "38b40090e470946b0a10c58dfd632425993fc823564eba2ccb2d07d5b8da530e", + "object_path": "lib/lean/Lean/Elab/PreDefinition/PartialFixpoint.olean", + "object_sha256": "4183b146b597c223eea7aedf993c099e7fbb088625a8794e5bbb7fc1521d276d", + "object_bytes": 18144, + "imports": [ + "Lean.Elab.PreDefinition.PartialFixpoint.Eqns", + "Lean.Elab.PreDefinition.PartialFixpoint.Main", + "Lean.Elab.PreDefinition.PartialFixpoint.Induction" + ] + }, + { + "module": "Lean.Elab.PreDefinition.Main", + "root": "lean", + "source_path": "src/lean/Lean/Elab/PreDefinition/Main.lean", + "source_sha256": "cc17c16b9ace3ac574b2c986240d221098684fde80134a51b5257755049a799d", + "object_path": "lib/lean/Lean/Elab/PreDefinition/Main.olean", + "object_sha256": "76064d7588a57f26484c7a2447e269d49f9574f61c0d98c89b5965b0d689ea82", + "object_bytes": 2129192, + "imports": [ + "Lean.Util.SCC", + "Lean.Elab.PreDefinition.Basic", + "Lean.Elab.PreDefinition.Structural", + "Lean.Elab.PreDefinition.WF.Main", + "Lean.Elab.PreDefinition.MkInhabitant", + "Lean.Elab.PreDefinition.PartialFixpoint" + ] + }, + { + "module": "Lean.Elab.MutualDef", + "root": "lean", + "source_path": "src/lean/Lean/Elab/MutualDef.lean", + "source_sha256": "a4c376c478b23670a7b5c7cfe6807b8fda822e9f00e0209e5137d7130b0dd4af", + "object_path": "lib/lean/Lean/Elab/MutualDef.olean", + "object_sha256": "dcc091c207e85ed290846b4da7cce505e1f4c12f658378793cde0383ee7b20aa", + "object_bytes": 5319360, + "imports": [ + "Lean.Parser.Term", + "Lean.Meta.Closure", + "Lean.Meta.Check", + "Lean.Meta.Transform", + "Lean.PrettyPrinter.Delaborator.Options", + "Lean.Elab.Command", + "Lean.Elab.Match", + "Lean.Elab.DefView", + "Lean.Elab.Deriving.Basic", + "Lean.Elab.PreDefinition.Main", + "Lean.Elab.PreDefinition.TerminationHint", + "Lean.Elab.DeclarationRange" + ] + }, + { + "module": "Lean.Meta.Constructions.NoConfusionLinear", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Constructions/NoConfusionLinear.lean", + "source_sha256": "66a73e3094ee1faf629f98ebaacb94551c112a16d04d6226f14a0dcffe9ca065", + "object_path": "lib/lean/Lean/Meta/Constructions/NoConfusionLinear.olean", + "object_sha256": "11843dca2e37b3d420c7563caf4f3168b5e528949e5d7f8df68cce02600ad3b4", + "object_bytes": 1005216, + "imports": [ + "Lean.AddDecl", + "Lean.Meta.AppBuilder", + "Lean.Meta.CompletionName" + ] + }, + { + "module": "Lean.Meta.Constructions.NoConfusion", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Constructions/NoConfusion.lean", + "source_sha256": "29c3b65b61743b54fe34c7e20de4c2d0a1c51305451e8d1f2f460e1e9e473773", + "object_path": "lib/lean/Lean/Meta/Constructions/NoConfusion.olean", + "object_sha256": "8041eeb44a0f2c14e0489a418dadcbd182c2173f6bc0b7c826bc7039d5b6c05d", + "object_bytes": 497560, + "imports": [ + "Lean.AddDecl", + "Lean.Meta.AppBuilder", + "Lean.Meta.CompletionName", + "Lean.Meta.Constructions.NoConfusionLinear" + ] + }, + { + "module": "Lean.Meta.Constructions.RecOn", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Constructions/RecOn.lean", + "source_sha256": "5d0706d3b51e23d1d8fd23f496a2c24ac8ca4911a23e6dd7e521ba92be17b9c4", + "object_path": "lib/lean/Lean/Meta/Constructions/RecOn.olean", + "object_sha256": "8287c3228dde76ffa5728428bfc0809577372ad4718f55308960edd09e882445", + "object_bytes": 205240, + "imports": [ + "Lean.Meta.InferType", + "Lean.AuxRecursor", + "Lean.AddDecl", + "Lean.Meta.CompletionName" + ] + }, + { + "module": "Lean.Meta.Constructions.BRecOn", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Constructions/BRecOn.lean", + "source_sha256": "30ecf2a09e5e9a05afb540c53ae1d20b3439134ef0e21ef330637f203b66aa14", + "object_path": "lib/lean/Lean/Meta/Constructions/BRecOn.olean", + "object_sha256": "12ad856a573885c9d5297e5162a660a3af6536f9dccdc7d3e6c8caedc09ccb56", + "object_bytes": 1065360, + "imports": [ + "Lean.Meta.InferType", + "Lean.AuxRecursor", + "Lean.AddDecl", + "Lean.Meta.CompletionName", + "Lean.Meta.PProdN" + ] + }, + { + "module": "Lean.Meta.Constructions", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Constructions.lean", + "source_sha256": "a03f3d963573fb74e275647eebe8ad368f4551feaf7e1ef1ac15ff19e3b506cb", + "object_path": "lib/lean/Lean/Meta/Constructions.olean", + "object_sha256": "030042de729a5ef6d452276a6faf3ebb932d2c272d5420814fe4d45981aa5033", + "object_bytes": 18216, + "imports": [ + "Lean.Meta.Constructions.CasesOn", + "Lean.Meta.Constructions.NoConfusion", + "Lean.Meta.Constructions.RecOn", + "Lean.Meta.Constructions.BRecOn" + ] + }, + { + "module": "Lean.Meta.SizeOf", + "root": "lean", + "source_path": "src/lean/Lean/Meta/SizeOf.lean", + "source_sha256": "6a72edbfdd7e569239fabe801eaf3a3e2bd27c30b04e90e206b8ebd116cf8df1", + "object_path": "lib/lean/Lean/Meta/SizeOf.olean", + "object_sha256": "609c2d31855e1a6534b3921e6d8b92c0265c116008de03e61efab71b6612bf06", + "object_bytes": 1681816, + "imports": [ + "Init.Data.List.BasicAux", + "Lean.AddDecl", + "Lean.Meta.AppBuilder", + "Lean.Meta.Instances" + ] + }, + { + "module": "Lean.Elab.ComputedFields", + "root": "lean", + "source_path": "src/lean/Lean/Elab/ComputedFields.lean", + "source_sha256": "1fbca3356bc761ccccbbf9d5e9b09c310fc199b2f6f79c2d0d9f8f97702cfa7d", + "object_path": "lib/lean/Lean/Elab/ComputedFields.olean", + "object_sha256": "683993fce7692d6bdeaec756e8ddf5da7fcab354c39bd2208eb8051795518969", + "object_bytes": 1092288, + "imports": [ + "Lean.Meta.Constructions.CasesOn", + "Lean.Compiler.ImplementedByAttr", + "Lean.Elab.PreDefinition.WF.Eqns" + ] + }, + { + "module": "Lean.Elab.MutualInductive", + "root": "lean", + "source_path": "src/lean/Lean/Elab/MutualInductive.lean", + "source_sha256": "c8dfca1fa8bf12e55e7d8913e7bf7a1eb4ec2f25ab8a7ddd37ae2a443adcb451", + "object_path": "lib/lean/Lean/Elab/MutualInductive.olean", + "object_sha256": "e363d4e7d8978439b12f7065be30de85d5fe2dd51b397e7d7ca2493aea66ecea", + "object_bytes": 4514864, + "imports": [ + "Lean.Util.ForEachExprWhere", + "Lean.Util.ReplaceLevel", + "Lean.Util.ReplaceExpr", + "Lean.Util.CollectLevelParams", + "Lean.Meta.Constructions", + "Lean.Meta.CollectFVars", + "Lean.Meta.SizeOf", + "Lean.Meta.Injective", + "Lean.Meta.IndPredBelow", + "Lean.Elab.Command", + "Lean.Elab.ComputedFields", + "Lean.Elab.DefView", + "Lean.Elab.DeclUtil", + "Lean.Elab.Deriving.Basic", + "Lean.Elab.DeclarationRange" + ] + }, + { + "module": "Lean.Elab.Declaration", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Declaration.lean", + "source_sha256": "75df42bd4acae23b5ac806097bd65ff0a87ca2e0179eab87c0461e279c1404a6", + "object_path": "lib/lean/Lean/Elab/Declaration.olean", + "object_sha256": "b2c150f6d646461170a71987f38607fa204bb024589f612e0410830ef11a26ea", + "object_bytes": 1372688, + "imports": [ + "Lean.Util.CollectLevelParams", + "Lean.Elab.DeclUtil", + "Lean.Elab.DefView", + "Lean.Elab.MutualDef", + "Lean.Elab.MutualInductive", + "Lean.Elab.DeclarationRange" + ] + }, + { + "module": "Lean.Meta.Tactic.FunIndInfo", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/FunIndInfo.lean", + "source_sha256": "77ac8f1209642dfce662b9f8910af58b41f5b6de20a59d3fe93bdf557bd50234", + "object_path": "lib/lean/Lean/Meta/Tactic/FunIndInfo.olean", + "object_sha256": "24a3cdd1a172e041539a39ed3129cf88f3550767babf4c41281f466996172279", + "object_bytes": 307688, + "imports": [ + "Lean.Meta.Basic", + "Lean.ScopedEnvExtension", + "Lean.ReservedNameAction" + ] + }, + { + "module": "Lean.Meta.Tactic.FunIndCollect", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/FunIndCollect.lean", + "source_sha256": "1152ddbd4dd1a2e39557e9304dfc32180971f0caeb246de993d50b49f0faa100", + "object_path": "lib/lean/Lean/Meta/Tactic/FunIndCollect.olean", + "object_sha256": "1983f0afd6dc67c5f3a0f1a0629080e33db3f8776f3e8d7c0ed945127e42a178", + "object_bytes": 609080, + "imports": [ + "Lean.Meta.Tactic.Util", + "Lean.Meta.Tactic.FunIndInfo" + ] + }, + { + "module": "Lean.Elab.Tactic.Generalize", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/Generalize.lean", + "source_sha256": "20a8eff229b993819b6d22f4e6a6dfa0bc16adf2ea7c37be1709903527b68cca", + "object_path": "lib/lean/Lean/Elab/Tactic/Generalize.olean", + "object_sha256": "7bf8eb11ab39309677992e304be6c190d42d4f494da6340fd92133064df80fcd", + "object_bytes": 269672, + "imports": [ + "Lean.Meta.Tactic.Generalize", + "Lean.Meta.Check", + "Lean.Meta.Tactic.Intro", + "Lean.Elab.Binders", + "Lean.Elab.Tactic.ElabTerm", + "Lean.Elab.Tactic.Location" + ] + }, + { + "module": "Lean.Elab.Tactic.Induction", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/Induction.lean", + "source_sha256": "4329b9371f90f94e62622248d97f8d764b9980aaa7d48e1caaf83d42fa26b470", + "object_path": "lib/lean/Lean/Elab/Tactic/Induction.olean", + "object_sha256": "cae5bc23f0edb817db0941e7f551664ef20644f030b5d0142629174d753be400", + "object_bytes": 4012296, + "imports": [ + "Lean.Util.CollectFVars", + "Lean.AuxRecursor", + "Lean.Parser.Term", + "Lean.Meta.RecursorInfo", + "Lean.Meta.CollectMVars", + "Lean.Meta.Tactic.ElimInfo", + "Lean.Meta.Tactic.FunIndInfo", + "Lean.Meta.Tactic.Induction", + "Lean.Meta.Tactic.Cases", + "Lean.Meta.Tactic.FunIndCollect", + "Lean.Meta.GeneralizeVars", + "Lean.Elab.App", + "Lean.Elab.Match", + "Lean.Elab.Tactic.ElabTerm", + "Lean.Elab.Tactic.Generalize" + ] + }, + { + "module": "Lean.Elab.Tactic.Injection", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/Injection.lean", + "source_sha256": "7063054c2f09d417c1d6601e9e1ecad7951355a14de140107823915dccb0a646", + "object_path": "lib/lean/Lean/Elab/Tactic/Injection.olean", + "object_sha256": "7b1060bf964e4e206abd3deae5a9abe6071abf83de6c55582aec1a98273b1d15", + "object_bytes": 161144, + "imports": [ + "Lean.Meta.Tactic.Injection", + "Lean.Meta.Tactic.Assumption", + "Lean.Elab.Tactic.ElabTerm" + ] + }, + { + "module": "Lean.Elab.Tactic.Match", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/Match.lean", + "source_sha256": "2d53eb28d7aaa3e0ec00f0f6ad828e9c8103377d132a6d575d1325e347fa6dae", + "object_path": "lib/lean/Lean/Elab/Tactic/Match.olean", + "object_sha256": "9713341539f4aeaf36790799432449b1356b9525aa03ab40afade508b9295b89", + "object_bytes": 376632, + "imports": [ + "Lean.Parser.Term", + "Lean.Elab.Match", + "Lean.Elab.Tactic.Basic", + "Lean.Elab.Tactic.Induction" + ] + }, + { + "module": "Lean.Elab.Tactic.Simproc", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/Simproc.lean", + "source_sha256": "d05ed9d5e5e945ae5432056ea2a81af7853a979acdf365fafd11dde7673424f2", + "object_path": "lib/lean/Lean/Elab/Tactic/Simproc.olean", + "object_sha256": "5d4e7dbfea9ab89af01d131066ecc48426d511feda0bf65177b331c08233885f", + "object_bytes": 338424, + "imports": [ + "Init.Simproc", + "Lean.ReservedNameAction", + "Lean.Meta.Tactic.Simp.Simproc", + "Lean.Elab.Binders", + "Lean.Elab.SyntheticMVars", + "Lean.Elab.Term", + "Lean.Elab.Command" + ] + }, + { + "module": "Lean.Elab.Tactic.Meta", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/Meta.lean", + "source_sha256": "ff491235bdcecfcfbda3848946734784ac2009dfb19762f75861a1f8c151e012", + "object_path": "lib/lean/Lean/Elab/Tactic/Meta.olean", + "object_sha256": "9023156daa2ba21e5c1f541380e2c86bbc5d13950e3e6a42d4b1674c3c0eee66", + "object_bytes": 195352, + "imports": [ + "Lean.Elab.SyntheticMVars", + "Lean.Elab.Tactic.Basic" + ] + }, + { + "module": "Lean.Elab.Calc", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Calc.lean", + "source_sha256": "133a37141b0a7ebb735c26c0768495604b3f5588f4582e172a7d0abdce200765", + "object_path": "lib/lean/Lean/Elab/Calc.olean", + "object_sha256": "013aab4aa141f32e13f8723d9d5756441206f838ecba58dfae4b0927f2ef62dc", + "object_bytes": 1432152, + "imports": [ + "Lean.Elab.App" + ] + }, + { + "module": "Lean.Elab.Tactic.Calc", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/Calc.lean", + "source_sha256": "55a650b44a381098274d5db643121db32155e7dcabd1ecf05298dab442184196", + "object_path": "lib/lean/Lean/Elab/Tactic/Calc.olean", + "object_sha256": "9c8d35fa8017137ee160800d6b80a84d944ea4511d795a70abb6e34c9d83e270", + "object_bytes": 241000, + "imports": [ + "Lean.Elab.Calc", + "Lean.Elab.Tactic.ElabTerm" + ] + }, + { + "module": "Lean.Elab.Tactic.Congr", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/Congr.lean", + "source_sha256": "155f4d93d3e7d79dbc5b97340669d8ff1b8f54bae2b44111641c5d50561ff722", + "object_path": "lib/lean/Lean/Elab/Tactic/Congr.olean", + "object_sha256": "c00c0e9b8ddae3f3ad7b701ac48a39fa7526b52a2bc713a16ccda3dcec752cb1", + "object_bytes": 95776, + "imports": [ + "Lean.Meta.Tactic.Congr", + "Lean.Elab.Tactic.Basic" + ] + }, + { + "module": "Lean.Elab.Tactic.Guard", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/Guard.lean", + "source_sha256": "74fad33731a73585b216b110da3e04b81f366e43dd80a007d7c96a15989dd349", + "object_path": "lib/lean/Lean/Elab/Tactic/Guard.olean", + "object_sha256": "68c2a0974f8e87ad1fc9113e9e466504af4f69fa262b72621e09a8445aeadc79", + "object_bytes": 734352, + "imports": [ + "Init.Guard", + "Lean.Elab.Command", + "Lean.Elab.Tactic.Conv.Basic", + "Lean.Meta.Basic", + "Lean.Meta.Eval" + ] + }, + { + "module": "Lean.Elab.Tactic.RCases", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/RCases.lean", + "source_sha256": "edc607a7633f1fffde0abd65135b7d26f3d9d62dae4b4577eada68f249f3d920", + "object_path": "lib/lean/Lean/Elab/Tactic/RCases.olean", + "object_sha256": "2f8344a17ca1c3d522392ff21c7ee953076d83b3262f7aa59f3327c5bb5be1ce", + "object_bytes": 2947336, + "imports": [ + "Lean.Elab.Tactic.Induction" + ] + }, + { + "module": "Lean.Elab.Tactic.Repeat", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/Repeat.lean", + "source_sha256": "ab552cec1025b197ffa52f47fde77a090c3742be206c2af08961175776ba7628", + "object_path": "lib/lean/Lean/Elab/Tactic/Repeat.olean", + "object_sha256": "99a934e66bdbad738d78a6d78fad062bbb98c34c211198b049f6d2f4af29350f", + "object_bytes": 217304, + "imports": [ + "Lean.Meta.Tactic.Repeat", + "Lean.Elab.Tactic.Basic" + ] + }, + { + "module": "Lean.Meta.Tactic.Ext", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Ext.lean", + "source_sha256": "c0dce3a0e48d83f16e4d9ff0f52f651beea9589fe3948d346952e3ba02a3f6f4", + "object_path": "lib/lean/Lean/Meta/Tactic/Ext.olean", + "object_sha256": "6e11501be14dafdec89c8e2d5108de0d07853de8f6dd37a867d08dea73b9bd4e", + "object_bytes": 453920, + "imports": [ + "Init.Data.Array.InsertionSort", + "Lean.Meta.DiscrTree" + ] + }, + { + "module": "Lean.Elab.Tactic.Ext", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/Ext.lean", + "source_sha256": "cbcda8c601ed31eff1a8ce9f3abd4a1a2c15df2e6a39dedb99cfd8afaeb7470b", + "object_path": "lib/lean/Lean/Elab/Tactic/Ext.olean", + "object_sha256": "93a983c79f7c3bf0d595fe76b969c2128f2f33c0a97e1306befad690b33923b1", + "object_bytes": 1707680, + "imports": [ + "Init.Ext", + "Lean.Meta.Tactic.Ext", + "Lean.Elab.DeclarationRange", + "Lean.Elab.Tactic.RCases", + "Lean.Elab.Tactic.Repeat", + "Lean.Elab.Tactic.BuiltinTactic", + "Lean.Elab.Command", + "Lean.Linter.Basic" + ] + }, + { + "module": "Lean.Elab.Tactic.FalseOrByContra", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/FalseOrByContra.lean", + "source_sha256": "6c753cee15196496d07295e2774766b4f90f35c2bac0e9d25765f109e9d0ffc2", + "object_path": "lib/lean/Lean/Elab/Tactic/FalseOrByContra.olean", + "object_sha256": "bb00c4bbd3dab9dd8a6897bdc03a9e9a4e57e3f2ddea574e2567807f1bc33ac8", + "object_bytes": 788768, + "imports": [ + "Lean.Elab.Tactic.Basic", + "Lean.Meta.Tactic.Apply", + "Lean.Meta.Tactic.Intro" + ] + }, + { + "module": "Lean.Meta.Canonicalizer", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Canonicalizer.lean", + "source_sha256": "f8cf10921a58d5408c2ae2d7838043fbc6aeb46e78bf041916043094776ddee3", + "object_path": "lib/lean/Lean/Meta/Canonicalizer.olean", + "object_sha256": "b6c7839c4fc63726c5208138cc7a0bd6de33434c65977191682b44fedaf95f08", + "object_bytes": 601920, + "imports": [ + "Lean.Util.ShareCommon", + "Lean.Meta.Basic", + "Lean.Meta.FunInfo", + "Std.Data.HashMap.Raw" + ] + }, + { + "module": "Lean.Elab.Tactic.Omega.OmegaM", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/Omega/OmegaM.lean", + "source_sha256": "c88a268c8ea469a17e125905bcd9c1dee3d75aad4269bf0001b3e678e4e51d40", + "object_path": "lib/lean/Lean/Elab/Tactic/Omega/OmegaM.olean", + "object_sha256": "7bd9cb72d574e0888315606c30f42bb4a9472dd1f7eb9569f2104527925a500f", + "object_bytes": 2432944, + "imports": [ + "Init.Omega.LinearCombo", + "Init.Omega.Int", + "Init.Omega.Logic", + "Init.Data.BitVec.Basic", + "Lean.Meta.AppBuilder", + "Lean.Meta.Canonicalizer", + "Std.Data.HashMap.Basic", + "Std.Data.HashSet.Basic" + ] + }, + { + "module": "Lean.Elab.Tactic.Omega.MinNatAbs", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/Omega/MinNatAbs.lean", + "source_sha256": "16c7e18e2c07c2f606e99843aa794200e86d15578159d9195ecf620e9fb95859", + "object_path": "lib/lean/Lean/Elab/Tactic/Omega/MinNatAbs.olean", + "object_sha256": "0a6ca9209722a0e581d2793d0d137dd001e0ddc1a9bcf1a6df4729efecc6b04d", + "object_bytes": 216352, + "imports": [ + "Init.BinderPredicates", + "Init.Data.Int.Order", + "Init.Data.List.MinMax", + "Init.Data.Nat.MinMax", + "Init.Data.Option.Lemmas" + ] + }, + { + "module": "Lean.Elab.Tactic.Omega.Core", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/Omega/Core.lean", + "source_sha256": "84129087c6235b80ca7dafcc515c2434b9e41cbd2a1bd8d2aa139709bf7b3d98", + "object_path": "lib/lean/Lean/Elab/Tactic/Omega/Core.olean", + "object_sha256": "76023e1ed634adb439f4ce04bbff64389da71a5d1221584a094840709e441b84", + "object_bytes": 2104328, + "imports": [ + "Init.Omega.Constraint", + "Lean.Elab.Tactic.Omega.OmegaM", + "Lean.Elab.Tactic.Omega.MinNatAbs" + ] + }, + { + "module": "Lean.Elab.Tactic.Omega.Frontend", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/Omega/Frontend.lean", + "source_sha256": "0b098168d77369b4b82523a1ead4af13359a02f25cf19c618f4bd25db4c57ab8", + "object_path": "lib/lean/Lean/Elab/Tactic/Omega/Frontend.olean", + "object_sha256": "e9060fa7b9b90a9e9367c3b885b34e1b194f7d1b168b148a8b17135f40204c43", + "object_bytes": 5506032, + "imports": [ + "Lean.Elab.Tactic.Omega.Core", + "Lean.Elab.Tactic.FalseOrByContra", + "Lean.Elab.Tactic.Config", + "Lean.Elab.MutualDef", + "Lean.Meta.Closure" + ] + }, + { + "module": "Lean.Elab.Tactic.Omega", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/Omega.lean", + "source_sha256": "d07da7c84651c88ae49d94cb623d4ad4073a48c908a9b1232e08bc5968a6c62b", + "object_path": "lib/lean/Lean/Elab/Tactic/Omega.olean", + "object_sha256": "306139b8444d92a1f7a980d59f900eb05a9fc9de2476e7be81e6e794e8be169b", + "object_bytes": 27168, + "imports": [ + "Lean.Elab.Tactic.Omega.Frontend" + ] + }, + { + "module": "Lean.Elab.Tactic.Simpa", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/Simpa.lean", + "source_sha256": "200e4aa29db4015d5ab5e19e6e21436f61d13bf0825ec5f9abf295cd0cec776e", + "object_path": "lib/lean/Lean/Elab/Tactic/Simpa.olean", + "object_sha256": "7e9ab04c06152d2e3b54d47519228563de88b48878c3b72563123be3f3228002", + "object_bytes": 958600, + "imports": [ + "Lean.Meta.Tactic.Assumption", + "Lean.Meta.Tactic.TryThis", + "Lean.Elab.Tactic.Simp", + "Lean.Elab.App", + "Lean.Linter.Basic" + ] + }, + { + "module": "Lean.Meta.Tactic.NormCast", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/NormCast.lean", + "source_sha256": "76b9c284192f9731bedb5709789896d962551626c2f371f2107a74ce75db4284", + "object_path": "lib/lean/Lean/Meta/Tactic/NormCast.olean", + "object_sha256": "d1186910ca82912371dca99c49e921c6923ef652df195e725546d69b3ddb7a64", + "object_bytes": 674704, + "imports": [ + "Lean.Meta.CongrTheorems", + "Lean.Meta.Tactic.Simp.Attr", + "Lean.Meta.CoeAttr" + ] + }, + { + "module": "Lean.Elab.Tactic.NormCast", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/NormCast.lean", + "source_sha256": "0aebd4de64028f311026d015daf8fe543a9c209e88a64be679999e29ee9fbad9", + "object_path": "lib/lean/Lean/Elab/Tactic/NormCast.olean", + "object_sha256": "2a9d358c03cf683e56b45732b02f59c20af7c2e8fffa6ec9a88b3c86c1b00b9c", + "object_bytes": 1538944, + "imports": [ + "Lean.Meta.Tactic.NormCast", + "Lean.Elab.Tactic.Conv.Simp", + "Lean.Elab.ElabRules" + ] + }, + { + "module": "Lean.Elab.Tactic.Symm", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/Symm.lean", + "source_sha256": "5bf84b3ce7914346efc8c105fe7d0b49e77b55833a6f6a656735a99a4e1c3704", + "object_path": "lib/lean/Lean/Elab/Tactic/Symm.olean", + "object_sha256": "b5729804f8077de676a6e973598de46856aeac921714a46b86a6f3603055eddc", + "object_bytes": 128568, + "imports": [ + "Lean.Meta.Tactic.Symm", + "Lean.Elab.Tactic.Location" + ] + }, + { + "module": "Lean.Elab.Tactic.SolveByElim", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/SolveByElim.lean", + "source_sha256": "8ed50abd2b627349464d095e02c96f8978a870fbad98daf313418594bdfb9bf4", + "object_path": "lib/lean/Lean/Elab/Tactic/SolveByElim.olean", + "object_sha256": "a2a008a25c1be4d0116d17ee49e33a63b547b4c5cf36f9eae0c1232bf277cc93", + "object_bytes": 658456, + "imports": [ + "Lean.Meta.Tactic.SolveByElim", + "Lean.Elab.Tactic.Config" + ] + }, + { + "module": "Lean.Meta.LazyDiscrTree", + "root": "lean", + "source_path": "src/lean/Lean/Meta/LazyDiscrTree.lean", + "source_sha256": "83f8ad3337890f8c0cc1fdfe8aac57c97158f25483ef712b4b3ac3b03683cd5d", + "object_path": "lib/lean/Lean/Meta/LazyDiscrTree.olean", + "object_sha256": "7a200d5232d81a68024efae947ee1dbe4b80fe2b7f7bd9b40f5d3844f38017cb", + "object_bytes": 2854040, + "imports": [ + "Lean.Meta.CompletionName", + "Lean.Meta.DiscrTree" + ] + }, + { + "module": "Lean.Util.Heartbeats", + "root": "lean", + "source_path": "src/lean/Lean/Util/Heartbeats.lean", + "source_sha256": "9e8498b6208d4d1768cffcd63c6165a9b440d820db4cf97cec44636e9f2d3158", + "object_path": "lib/lean/Lean/Util/Heartbeats.olean", + "object_sha256": "9570ed82d016b9d17f829c442525506c48e6808d3cba2cb0e3c0962634ab9bc7", + "object_bytes": 90520, + "imports": [ + "Lean.CoreM" + ] + }, + { + "module": "Lean.Meta.Tactic.LibrarySearch", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/LibrarySearch.lean", + "source_sha256": "5ff9a84b58621958ad25595ebc432649adb6992f774eb33b658c20d8e76e7e66", + "object_path": "lib/lean/Lean/Meta/Tactic/LibrarySearch.olean", + "object_sha256": "9284198ffb5577ca38aabd4d15222568b4eb28283aef332a9bf6f6a7bec7c32e", + "object_bytes": 714208, + "imports": [ + "Init.Data.Nat.MinMax", + "Lean.Meta.LazyDiscrTree", + "Lean.Meta.Tactic.SolveByElim", + "Lean.Util.Heartbeats" + ] + }, + { + "module": "Lean.Elab.Tactic.LibrarySearch", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/LibrarySearch.lean", + "source_sha256": "6ab3d5a8dff28a4343c2bd6a7b778fe1b67fec855129967deccac7c9da022c97", + "object_path": "lib/lean/Lean/Elab/Tactic/LibrarySearch.olean", + "object_sha256": "1d644c57ed5940055d435c02b64fb20726d59bb3e3c18d160387996dc64cad65", + "object_bytes": 383296, + "imports": [ + "Lean.Meta.Tactic.LibrarySearch", + "Lean.Meta.Tactic.TryThis", + "Lean.Elab.Tactic.ElabTerm" + ] + }, + { + "module": "Lean.Elab.Tactic.ShowTerm", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/ShowTerm.lean", + "source_sha256": "034a07b331d077b2eb6985ff9029dbdf15d2d74698938f936ee2f8a4d9f68187", + "object_path": "lib/lean/Lean/Elab/Tactic/ShowTerm.olean", + "object_sha256": "203e9945eaf6de10b9ee2de4c5a7251164de5cb16c4717f0c46c99c99328cd51", + "object_bytes": 129736, + "imports": [ + "Lean.Elab.ElabRules", + "Lean.Meta.Tactic.TryThis" + ] + }, + { + "module": "Lean.Meta.Tactic.Rfl", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Rfl.lean", + "source_sha256": "d0f59076e4f497ed1673f5b424cf694aefd7095400e6f130b536bbc2d9b32f06", + "object_path": "lib/lean/Lean/Meta/Tactic/Rfl.olean", + "object_sha256": "d5852813b9378c8b9c286bf5d5b3ecb42a93ee3a373916e4c1afa61007334b10", + "object_bytes": 751512, + "imports": [ + "Lean.Meta.Tactic.Apply", + "Lean.Elab.Tactic.Basic", + "Lean.Meta.Tactic.Refl" + ] + }, + { + "module": "Lean.Elab.Tactic.Rfl", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/Rfl.lean", + "source_sha256": "eb22207aae825d8605ad8237f9c4e5537355554a61efcf4c518ad023c7134335", + "object_path": "lib/lean/Lean/Elab/Tactic/Rfl.olean", + "object_sha256": "4f6e943881defb3986cbcaf33211e572ca9d014096587a85c3e7ed80f18daedc", + "object_bytes": 63968, + "imports": [ + "Lean.Meta.Tactic.Rfl", + "Lean.Elab.Tactic.Basic" + ] + }, + { + "module": "Lean.Meta.Tactic.Rewrites", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Rewrites.lean", + "source_sha256": "426dd3d2b08b3a8c0553ef933d0c77bd309e91a7234dd459fc31b96c317d148f", + "object_path": "lib/lean/Lean/Meta/Tactic/Rewrites.olean", + "object_sha256": "5223cc2a39f7dfe7cd5ebef62367dcf040786f24cd63c92cd9d5ee0e82a07913", + "object_bytes": 1353624, + "imports": [ + "Lean.Meta.LazyDiscrTree", + "Lean.Meta.Tactic.Assumption", + "Lean.Meta.Tactic.Rewrite", + "Lean.Meta.Tactic.Refl", + "Lean.Meta.Tactic.SolveByElim", + "Lean.Meta.Tactic.TryThis", + "Lean.Util.Heartbeats" + ] + }, + { + "module": "Lean.Elab.Tactic.Rewrites", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/Rewrites.lean", + "source_sha256": "a8308b05e2c6d5c3d42818c88921a2616861523e85efca46e6886b73b0b5942d", + "object_path": "lib/lean/Lean/Elab/Tactic/Rewrites.olean", + "object_sha256": "273986e5bb645fa3d89f9193d8263a6125e8bb11d3c91a0683ac4ea47533a3da", + "object_bytes": 438664, + "imports": [ + "Lean.Elab.Tactic.Location", + "Lean.Meta.Tactic.Replace", + "Lean.Meta.Tactic.Rewrites" + ] + }, + { + "module": "Lean.Elab.Tactic.DiscrTreeKey", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/DiscrTreeKey.lean", + "source_sha256": "c63a552cb08c0a6397910bc48c495f91f755da990c9aea5ff1aa969c4399d6f6", + "object_path": "lib/lean/Lean/Elab/Tactic/DiscrTreeKey.olean", + "object_sha256": "9441602498d256ca2c08b7e941e0646898e78a14faae2e0030902edbfc890e04", + "object_bytes": 253568, + "imports": [ + "Init.Tactics", + "Lean.Elab.Command", + "Lean.Meta.Tactic.Simp.SimpTheorems" + ] + }, + { + "module": "Std.Sat.CNF.Literal", + "root": "lean", + "source_path": "src/lean/Std/Sat/CNF/Literal.lean", + "source_sha256": "80ce8f9bac953fc28f4638c1540d728599ab9101bdd638b3824187206ac32986", + "object_path": "lib/lean/Std/Sat/CNF/Literal.olean", + "object_sha256": "e76fcdcb18a397aeef7aa10df5968d9bb77252219be911a367d5db44c8bbdabc", + "object_bytes": 27728, + "imports": [ + "Init.Data.Hashable", + "Init.Data.ToString" + ] + }, + { + "module": "Std.Sat.CNF.Basic", + "root": "lean", + "source_path": "src/lean/Std/Sat/CNF/Basic.lean", + "source_sha256": "86b2251f2d777dfac0919d91e5a6c88ac0b0641bd5ae8cfbbe8ab7c9e91dac73", + "object_path": "lib/lean/Std/Sat/CNF/Basic.olean", + "object_sha256": "407e9c5ff0d8757de41d455a6933fe203a9f161842a03341105c0b2b23736947", + "object_bytes": 246752, + "imports": [ + "Init.Data.List.Lemmas", + "Init.Data.List.Impl", + "Std.Sat.CNF.Literal" + ] + }, + { + "module": "Std.Sat.CNF.Relabel", + "root": "lean", + "source_path": "src/lean/Std/Sat/CNF/Relabel.lean", + "source_sha256": "243a477a7e3e8249f3930e1abc03a79f6e5a4e0878c4709ac4de30ddb2410c04", + "object_path": "lib/lean/Std/Sat/CNF/Relabel.olean", + "object_sha256": "fe162ac2e14edb8172aa59f115ee85ab4ad403e05ae1ea3279b3c900820de94f", + "object_bytes": 169632, + "imports": [ + "Std.Sat.CNF.Basic" + ] + }, + { + "module": "Std.Sat.CNF.RelabelFin", + "root": "lean", + "source_path": "src/lean/Std/Sat/CNF/RelabelFin.lean", + "source_sha256": "4952bc80c03bfa509eb5f1eddee1f5b404e6fc5eec92fc0e60c63b009c70fc60", + "object_path": "lib/lean/Std/Sat/CNF/RelabelFin.olean", + "object_sha256": "69757a7d8f01dda65da21731a54d69357bf633f452525a0d7fcc4ccad04b41ef", + "object_bytes": 189944, + "imports": [ + "Init.Data.List.Nat.Basic", + "Std.Sat.CNF.Relabel" + ] + }, + { + "module": "Std.Sat.CNF.Dimacs", + "root": "lean", + "source_path": "src/lean/Std/Sat/CNF/Dimacs.lean", + "source_sha256": "a95a9bc7246db0a20f5eff2488ae98202bb7b684c501ce7526c731ef81233264", + "object_path": "lib/lean/Std/Sat/CNF/Dimacs.olean", + "object_sha256": "451893fd1333bd9844c17e3683c1b600f2669121ade9ffe53ca7442f5e4d7f4d", + "object_bytes": 121552, + "imports": [ + "Std.Sat.CNF.Basic", + "Std.Sat.CNF.RelabelFin" + ] + }, + { + "module": "Std.Sat.CNF", + "root": "lean", + "source_path": "src/lean/Std/Sat/CNF.lean", + "source_sha256": "44e9304fa18e5d18264dc033fe2bd5a5caa8dd03bbde8928552cac7dabe57abe", + "object_path": "lib/lean/Std/Sat/CNF.olean", + "object_sha256": "4f9205ea5f646000d1b067780468681909ff5fe6d203a71350b4b3f469a125b8", + "object_bytes": 18456, + "imports": [ + "Std.Sat.CNF.Basic", + "Std.Sat.CNF.Literal", + "Std.Sat.CNF.Relabel", + "Std.Sat.CNF.RelabelFin", + "Std.Sat.CNF.Dimacs" + ] + }, + { + "module": "Std.Tactic.BVDecide.LRAT.Actions", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/LRAT/Actions.lean", + "source_sha256": "6d9996944e1e803dfd0d16c1c5d910b6ce5d5721bef88383158a424f848ea3fd", + "object_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Actions.olean", + "object_sha256": "db2879345ea2c69c189f6a43e960012b48aa1ad56a5b961bb7736f4c2a87bbda", + "object_bytes": 403776, + "imports": [ + "Std.Sat.CNF" + ] + }, + { + "module": "Lean.Elab.Tactic.BVDecide.LRAT.Trim", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/BVDecide/LRAT/Trim.lean", + "source_sha256": "630ae51a9289fba65803e5f5310c5061a6a5bc1990be8598c7e32f738bc11ed1", + "object_path": "lib/lean/Lean/Elab/Tactic/BVDecide/LRAT/Trim.olean", + "object_sha256": "d4a94fd1d09514c377a2d052474b4861988e5352e8cb7380b531b55d8cf49e9c", + "object_bytes": 503240, + "imports": [ + "Init.Data.Nat.Fold", + "Std.Tactic.BVDecide.LRAT.Actions", + "Std.Data.HashMap" + ] + }, + { + "module": "Lean.Elab.Tactic.BVDecide.LRAT", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/BVDecide/LRAT.lean", + "source_sha256": "607319aeb9eabe8878f8d05cb4ebab3b6a09d065f1d0d79126546e173998e933", + "object_path": "lib/lean/Lean/Elab/Tactic/BVDecide/LRAT.olean", + "object_sha256": "7a888d0c92a3bc9fbfae5275730fbc0c2d4a403029d159d355baf45994a0ebd1", + "object_bytes": 18288, + "imports": [ + "Lean.Elab.Tactic.BVDecide.LRAT.Trim" + ] + }, + { + "module": "Std.Tactic.BVDecide.LRAT.Parser", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/LRAT/Parser.lean", + "source_sha256": "9f7f1c53e6f64dbf3dbabffd42e68eb4ed377bab2db1a94e6c7a1296c61fb809", + "object_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Parser.olean", + "object_sha256": "dad1ad347ffc9aba685856c5ff02d2afb9a124c3ec35cdd97f123120d6c8e604", + "object_bytes": 727808, + "imports": [ + "Init.System.IO", + "Std.Tactic.BVDecide.LRAT.Actions", + "Std.Internal.Parsec" + ] + }, + { + "module": "Lean.Elab.Tactic.BVDecide.External", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/BVDecide/External.lean", + "source_sha256": "5218659473780fe96487cdee9d0ad3d6bae9c1467532e3b5c5811c46eb0d614d", + "object_path": "lib/lean/Lean/Elab/Tactic/BVDecide/External.olean", + "object_sha256": "28f562329f15fe65f11a56db33071cc8b727609bbdb6336893e62acd4eb0a760", + "object_bytes": 430656, + "imports": [ + "Std.Tactic.BVDecide.LRAT.Parser", + "Lean.CoreM", + "Std.Internal.Parsec" + ] + }, + { + "module": "Std.Tactic.BVDecide.Syntax", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Syntax.lean", + "source_sha256": "8b288b0d48a20db0fcad56585a4f4f1fa1ff6bb65e81cb25b17c99ad04276070", + "object_path": "lib/lean/Std/Tactic/BVDecide/Syntax.olean", + "object_sha256": "6985dbc4aab1f4a207abcd38cf324fc5105aa2b54a89d2ca0eb9344f768d2d51", + "object_bytes": 310360, + "imports": [ + "Init.Notation", + "Init.Simproc" + ] + }, + { + "module": "Lean.Elab.Tactic.BVDecide.Frontend.Attr", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/BVDecide/Frontend/Attr.lean", + "source_sha256": "ac9afb133509cb5ac3bd4d455b28c95802d87576999afff08326cc0e66e8260c", + "object_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Attr.olean", + "object_sha256": "02cd2cf6bbd521120a0f94f21834b5b1575a50587b214be33e60a5083e51d30b", + "object_bytes": 374208, + "imports": [ + "Lean.Util.Trace", + "Lean.Elab.Tactic.Simp", + "Std.Tactic.BVDecide.Syntax" + ] + }, + { + "module": "Std.Data.HashSet.Lemmas", + "root": "lean", + "source_path": "src/lean/Std/Data/HashSet/Lemmas.lean", + "source_sha256": "1ada3f0a1e8487632d3032c001536577f0eebc69da7c8a42f9da873d2a5642dc", + "object_path": "lib/lean/Std/Data/HashSet/Lemmas.olean", + "object_sha256": "9184e1e0334f99025a713737d80d92d475e87d17656bf14f0a1db76ead774660", + "object_bytes": 554944, + "imports": [ + "Std.Data.HashMap.Lemmas", + "Std.Data.HashSet.Basic" + ] + }, + { + "module": "Std.Data.HashSet", + "root": "lean", + "source_path": "src/lean/Std/Data/HashSet.lean", + "source_sha256": "a11f4964b920fbacfc8a08ada4492a7efeb176d1e1f08c086eee0ca1ef705aa2", + "object_path": "lib/lean/Std/Data/HashSet.olean", + "object_sha256": "e56b3805da8c8f2d2723ee5afb21393aa2f119ae706504e84639bd01e3eef420", + "object_bytes": 18136, + "imports": [ + "Std.Data.HashSet.Basic", + "Std.Data.HashSet.Lemmas" + ] + }, + { + "module": "Std.Sat.AIG.Basic", + "root": "lean", + "source_path": "src/lean/Std/Sat/AIG/Basic.lean", + "source_sha256": "94f421b757fca4ba1742cab64c66a9e5227962dba07b0da98aeba7cc881031d7", + "object_path": "lib/lean/Std/Sat/AIG/Basic.olean", + "object_sha256": "4c4d34486e318a5bbd8e34e4bf9e749bdc029af324841c5a3678f822d11b1cd2", + "object_bytes": 2015024, + "imports": [ + "Std.Data.HashSet", + "Init.Data.Vector.Basic" + ] + }, + { + "module": "Std.Sat.AIG.LawfulOperator", + "root": "lean", + "source_path": "src/lean/Std/Sat/AIG/LawfulOperator.lean", + "source_sha256": "89c473dcd7a13eee67555e835e3c5aaab42b665c92a49a160752cb04342bc4f9", + "object_path": "lib/lean/Std/Sat/AIG/LawfulOperator.olean", + "object_sha256": "c3a09f1a56e0f852a33b0b496ef0e926e80987f10ed166fe5cd6b656a450400c", + "object_bytes": 403392, + "imports": [ + "Std.Sat.AIG.Basic" + ] + }, + { + "module": "Std.Sat.AIG.Lemmas", + "root": "lean", + "source_path": "src/lean/Std/Sat/AIG/Lemmas.lean", + "source_sha256": "531ab2918cac3e8ac37751f50af4e193970fe21469d28890c9e69698b283a515", + "object_path": "lib/lean/Std/Sat/AIG/Lemmas.olean", + "object_sha256": "87b8c6eee0e69ae99afa6f4adda4614210f4ff2815b747d459dcd9488ac12a93", + "object_bytes": 664048, + "imports": [ + "Std.Sat.AIG.Basic", + "Std.Sat.AIG.LawfulOperator" + ] + }, + { + "module": "Std.Sat.AIG.CNF", + "root": "lean", + "source_path": "src/lean/Std/Sat/AIG/CNF.lean", + "source_sha256": "f1a855790d4cc2d4dc777d6b839c47f08f7ea9759673081141b02cf830bde8e2", + "object_path": "lib/lean/Std/Sat/AIG/CNF.olean", + "object_sha256": "b7f4324cc825f1e051d0ea764d8287b9cda671fb7bd66bde247d60c19a0d1d0b", + "object_bytes": 1321728, + "imports": [ + "Std.Sat.CNF", + "Std.Sat.AIG.Basic", + "Std.Sat.AIG.Lemmas" + ] + }, + { + "module": "Std.Sat.AIG.Relabel", + "root": "lean", + "source_path": "src/lean/Std/Sat/AIG/Relabel.lean", + "source_sha256": "91c465235af434b0ab679fbbbc72d646de6de31d21e5f453e02d7299b44f66bf", + "object_path": "lib/lean/Std/Sat/AIG/Relabel.olean", + "object_sha256": "78207645aa43c153a622d35cb0057b662f1cfda8f00f2f99e36b224c885e93a2", + "object_bytes": 352848, + "imports": [ + "Std.Sat.AIG.Basic", + "Std.Sat.AIG.Lemmas" + ] + }, + { + "module": "Std.Sat.AIG.RelabelNat", + "root": "lean", + "source_path": "src/lean/Std/Sat/AIG/RelabelNat.lean", + "source_sha256": "093084c2480b82bdfda550102ad5878ee7da5b9ba29cff9325af23116fd90954", + "object_path": "lib/lean/Std/Sat/AIG/RelabelNat.olean", + "object_sha256": "ae81c8a6c89ae567331f8cc835c28234baf10c32b670da0fb28c2787c37ab4a4", + "object_bytes": 807888, + "imports": [ + "Std.Sat.AIG.Relabel" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast.BoolExpr.Basic", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast/BoolExpr/Basic.lean", + "source_sha256": "44ec5247418bca643d549e79e173c42bf62afb1381553704e6f4cd632ca6a968", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BoolExpr/Basic.olean", + "object_sha256": "5941e0d6762438b65bc619512e92cc71728ec6ca28f7365190e392d2d7ae6fe6", + "object_bytes": 238216, + "imports": [ + "Init.Notation", + "Init.Data.Bool" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast.BoolExpr", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast/BoolExpr.lean", + "source_sha256": "ec77de858830f1fcbdef884d61fdfe879be796903c64ea17c2fbf109d99d9a51", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BoolExpr.olean", + "object_sha256": "a1799e683426982d51fbca6be1b0750d78b4b926c536e264bdcab08718d051be", + "object_bytes": 18384, + "imports": [ + "Std.Tactic.BVDecide.Bitblast.BoolExpr.Basic" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast.BVExpr.Basic", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Basic.lean", + "source_sha256": "e8d4f4446d1701fc6e32003c035cbe05a834373d2c90385cb420986f2b0a2ba0", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Basic.olean", + "object_sha256": "f32516afb0e284d3c6402da00a23c008f2d9081fe30560daaba1b0aa545fbc3c", + "object_bytes": 2517304, + "imports": [ + "Init.Data.Hashable", + "Init.Data.BitVec", + "Init.Data.RArray", + "Std.Tactic.BVDecide.Bitblast.BoolExpr.Basic" + ] + }, + { + "module": "Std.Sat.AIG.Cached", + "root": "lean", + "source_path": "src/lean/Std/Sat/AIG/Cached.lean", + "source_sha256": "7490a68df7bfc99dd73cc88d0c5428dcab642269fa0e3bd203f0a36fd626a60a", + "object_path": "lib/lean/Std/Sat/AIG/Cached.olean", + "object_sha256": "2148d8de9e62e098c4677bf3c94c902cb8911daa9d11fe2ed6c05b64149562c3", + "object_bytes": 450232, + "imports": [ + "Std.Sat.AIG.Basic", + "Std.Sat.AIG.Lemmas" + ] + }, + { + "module": "Std.Sat.AIG.CachedLemmas", + "root": "lean", + "source_path": "src/lean/Std/Sat/AIG/CachedLemmas.lean", + "source_sha256": "073c88fac070e3c9e9c6bcf41357d4465d77b018230e9034f8b6b5c9cb30665a", + "object_path": "lib/lean/Std/Sat/AIG/CachedLemmas.olean", + "object_sha256": "bd6bf17a67e33d54ffd426b5a68a18673abf66c7fa71bee5ae3dabaea4e43c50", + "object_bytes": 1069864, + "imports": [ + "Std.Sat.AIG.Cached" + ] + }, + { + "module": "Std.Sat.AIG.CachedGates", + "root": "lean", + "source_path": "src/lean/Std/Sat/AIG/CachedGates.lean", + "source_sha256": "b1787d8553feac29a5977272f0d234aba451a3e0168c967f279e4c9f511998ad", + "object_path": "lib/lean/Std/Sat/AIG/CachedGates.olean", + "object_sha256": "3870a4e060e2b40680e54a891b6965de2860c7eb1a6a7154183b469d2546aeb5", + "object_bytes": 162296, + "imports": [ + "Std.Sat.AIG.Cached", + "Std.Sat.AIG.CachedLemmas" + ] + }, + { + "module": "Std.Sat.AIG.CachedGatesLemmas", + "root": "lean", + "source_path": "src/lean/Std/Sat/AIG/CachedGatesLemmas.lean", + "source_sha256": "0feb395bd58bb6f002619f5a59a04a73790fdc20b8d2bafd7f388b2582273944", + "object_path": "lib/lean/Std/Sat/AIG/CachedGatesLemmas.olean", + "object_sha256": "7269fe3d4ae1e81170143dd2cdeb4b1a4d02c584a7884240c3ae34da09e5a8f0", + "object_bytes": 186504, + "imports": [ + "Std.Sat.AIG.CachedGates", + "Std.Sat.AIG.LawfulOperator" + ] + }, + { + "module": "Std.Sat.AIG.RefVec", + "root": "lean", + "source_path": "src/lean/Std/Sat/AIG/RefVec.lean", + "source_sha256": "2d8701bffba940515632a0d8c5e8bff97a1f3090159265c0005214d7ae284b9e", + "object_path": "lib/lean/Std/Sat/AIG/RefVec.olean", + "object_sha256": "45ee1f99112d470393f2013e1133eb6a32db1d7144443c5b57bfe663df320fb1", + "object_bytes": 454000, + "imports": [ + "Std.Sat.AIG.LawfulOperator", + "Std.Sat.AIG.CachedGatesLemmas", + "Init.Data.Vector.Lemmas" + ] + }, + { + "module": "Std.Sat.AIG.LawfulVecOperator", + "root": "lean", + "source_path": "src/lean/Std/Sat/AIG/LawfulVecOperator.lean", + "source_sha256": "189d35003abb806f9b9dd8abda21946f27d7e4f4ebb37dd19aaadc5a21ace05b", + "object_path": "lib/lean/Std/Sat/AIG/LawfulVecOperator.olean", + "object_sha256": "fe6657c7ba57332b8bdb5b69c092ec7c735e2e48d02bcca072a8d8b0b6b5cdc2", + "object_bytes": 123464, + "imports": [ + "Std.Sat.AIG.LawfulOperator", + "Std.Sat.AIG.RefVec" + ] + }, + { + "module": "Std.Sat.AIG.RefVecOperator.Map", + "root": "lean", + "source_path": "src/lean/Std/Sat/AIG/RefVecOperator/Map.lean", + "source_sha256": "081fc40fd1d2974599f71dfa28044353313ad66a76cafbb4412293982701161c", + "object_path": "lib/lean/Std/Sat/AIG/RefVecOperator/Map.olean", + "object_sha256": "0c42c0d702219e85ad8c980d34c316c0355e9e0e90a0cf49db84fa693e62e834", + "object_bytes": 1008584, + "imports": [ + "Std.Sat.AIG.RefVec", + "Std.Sat.AIG.LawfulVecOperator" + ] + }, + { + "module": "Std.Sat.AIG.RefVecOperator.Zip", + "root": "lean", + "source_path": "src/lean/Std/Sat/AIG/RefVecOperator/Zip.lean", + "source_sha256": "29f4393784a0adbc3e17858922bbff0f67112607cf8d63ead99188d781acb138", + "object_path": "lib/lean/Std/Sat/AIG/RefVecOperator/Zip.olean", + "object_sha256": "95ad317cefe2e989f29553c4514051bd3818722821d4378fd73bcdf7f3c695b6", + "object_bytes": 1269200, + "imports": [ + "Std.Sat.AIG.RefVec", + "Std.Sat.AIG.LawfulVecOperator" + ] + }, + { + "module": "Std.Sat.AIG.RefVecOperator.Fold", + "root": "lean", + "source_path": "src/lean/Std/Sat/AIG/RefVecOperator/Fold.lean", + "source_sha256": "8de8fffeac6fd74e0aab05d7fbb059b53c10679a1fa89a000164338dce606d51", + "object_path": "lib/lean/Std/Sat/AIG/RefVecOperator/Fold.olean", + "object_sha256": "07cdf5d6ff0b5abcc8108b512f7119cd517b19f1072265106497d11243350e6d", + "object_bytes": 559336, + "imports": [ + "Std.Sat.AIG.RefVec", + "Std.Sat.AIG.LawfulVecOperator" + ] + }, + { + "module": "Std.Sat.AIG.RefVecOperator", + "root": "lean", + "source_path": "src/lean/Std/Sat/AIG/RefVecOperator.lean", + "source_sha256": "1c61ce8b6ce6ab68345c2e3fc55fb0b0ac814b26f2e4de2f844a2969f7462b08", + "object_path": "lib/lean/Std/Sat/AIG/RefVecOperator.olean", + "object_sha256": "b84d5fc43f0faa29fadd04dbea06a3a91549b848cfeae858829a131c4b38a2f4", + "object_bytes": 18320, + "imports": [ + "Std.Sat.AIG.RefVecOperator.Map", + "Std.Sat.AIG.RefVecOperator.Zip", + "Std.Sat.AIG.RefVecOperator.Fold" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Eq", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Eq.lean", + "source_sha256": "9c39fab4781e1e6830df39353a41622f1f2196d4524f86f8c7154ee52ebd87f4", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Eq.olean", + "object_sha256": "3ef5313595a71bf802316b6c3142f22190a91bc13b1545f7897656f327e59bf8", + "object_bytes": 89592, + "imports": [ + "Std.Sat.AIG.CachedGatesLemmas", + "Std.Sat.AIG.LawfulVecOperator", + "Std.Sat.AIG.RefVecOperator" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Add.lean", + "source_sha256": "62132dc3a25b1e693901b1cdff596920d997625299068108892106eba6598bc6", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Add.olean", + "object_sha256": "556b2ba43490979059069316ce411b8bfb1b7693cb82d8a1bb134e8911ce9c76", + "object_bytes": 1054504, + "imports": [ + "Std.Tactic.BVDecide.Bitblast.BVExpr.Basic", + "Std.Sat.AIG.CachedGatesLemmas", + "Std.Sat.AIG.LawfulVecOperator" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Carry", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Carry.lean", + "source_sha256": "a735d6031236bb93081126737bfa53196970372f765f5a20583db72e0a087faf", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Carry.olean", + "object_sha256": "38d4e246d39f34f89f4c65afded6100abdc089e191c10e92545f28aef41fe931", + "object_bytes": 525416, + "imports": [ + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Not", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Not.lean", + "source_sha256": "541e516fb65ab9d5df932aed19ed43b089beec4f01539963df791cd20d6dd480", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Not.olean", + "object_sha256": "1abb81ea472ca981b3f62c9b2e59b4bc4c339a0004ae61bd2856b7c5e728bd2d", + "object_bytes": 44152, + "imports": [ + "Std.Tactic.BVDecide.Bitblast.BVExpr.Basic", + "Std.Sat.AIG.CachedGatesLemmas", + "Std.Sat.AIG.LawfulVecOperator", + "Std.Sat.AIG.RefVecOperator" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Ult", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Ult.lean", + "source_sha256": "ff2621d8b2c1ba04fd79dc4d15743ca5a451269a8180b686b96010c9b939fdcf", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Ult.olean", + "object_sha256": "2f27b553480533d225fe5a8ac065141f9f04350179e75343f34c2bb64e5bd11f", + "object_bytes": 100064, + "imports": [ + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Carry", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Not" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.GetLsbD", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/GetLsbD.lean", + "source_sha256": "9267098c52bfc5b3906e202ca53778283fde6b41f074790729c4dac80739c529", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/GetLsbD.olean", + "object_sha256": "8b1ab5270d735512f5104b6013e8a5b6f3739b2bfdfe6f6a6ba894d474b9d55d", + "object_bytes": 131888, + "imports": [ + "Std.Sat.AIG.CachedGatesLemmas", + "Std.Sat.AIG.RefVec" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Var", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Var.lean", + "source_sha256": "c3e3d12f8ff6dc90eaad2e9c970591633e49b37fe5cd3f466170ff2bf3113557", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Var.olean", + "object_sha256": "3d6c712f4a512a31289a80f1a76ab2ee1cc976eb7a73171b749af64c76bd720a", + "object_bytes": 398056, + "imports": [ + "Std.Tactic.BVDecide.Bitblast.BVExpr.Basic", + "Std.Sat.AIG.CachedGatesLemmas", + "Std.Sat.AIG.LawfulVecOperator" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Const", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Const.lean", + "source_sha256": "a240791f202d2e05b711b6b05ed79cb905a3ef780b072897debc02777dd4fb35", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Const.olean", + "object_sha256": "f0e57215afe8e10d4d4fb216c466f467bf2b9778118f67724eb309f3ed4760fa", + "object_bytes": 349816, + "imports": [ + "Std.Tactic.BVDecide.Bitblast.BVExpr.Basic", + "Std.Sat.AIG.CachedGatesLemmas", + "Std.Sat.AIG.LawfulVecOperator" + ] + }, + { + "module": "Std.Sat.AIG.If", + "root": "lean", + "source_path": "src/lean/Std/Sat/AIG/If.lean", + "source_sha256": "034049802b6123577c8d58c1a8e4c0743365d4bb86646d8872601318cbdadf8e", + "object_path": "lib/lean/Std/Sat/AIG/If.olean", + "object_sha256": "29f6e2ca019656d9263ee8abfe0ce1434fec8307a596cda528cdff027564a262", + "object_bytes": 1485104, + "imports": [ + "Std.Sat.AIG.CachedGatesLemmas", + "Std.Sat.AIG.LawfulVecOperator" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/ShiftLeft.lean", + "source_sha256": "581a8a11d4e3b306af75f40b11ccb4901cdbb8c5207d247fd32c6c0cb770a051", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/ShiftLeft.olean", + "object_sha256": "36edf91425c822a99d0509896f327e20acdd48cbba5b28f22be88e9fd214ee03", + "object_bytes": 1046616, + "imports": [ + "Std.Tactic.BVDecide.Bitblast.BVExpr.Basic", + "Std.Sat.AIG.CachedGatesLemmas", + "Std.Sat.AIG.LawfulVecOperator", + "Std.Sat.AIG.If" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftRight", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/ShiftRight.lean", + "source_sha256": "abe8a6bd6b45c52ae9bcc98a0147891f732a6f06e7bbf69246e5889b3a1b85e1", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/ShiftRight.olean", + "object_sha256": "e8df6d91c8148227fb6ae71cc0d1c96767bad26fd4a423b266f2a4c59a445b0e", + "object_bytes": 1373096, + "imports": [ + "Std.Tactic.BVDecide.Bitblast.BVExpr.Basic", + "Std.Sat.AIG.CachedGatesLemmas", + "Std.Sat.AIG.LawfulVecOperator", + "Std.Sat.AIG.If" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Append", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Append.lean", + "source_sha256": "4e455b1e39a7e7db5f124e894f632fa1086295fdab33989bd275d1b370529f70", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Append.olean", + "object_sha256": "70c0480d8ececb3a323824f08f7adf952eefa3357c8c744104d030092281c027", + "object_bytes": 162024, + "imports": [ + "Std.Tactic.BVDecide.Bitblast.BVExpr.Basic", + "Std.Sat.AIG.LawfulVecOperator" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Replicate", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Replicate.lean", + "source_sha256": "f8a359da423631a4a44ebbc3a6cdab92f30abb51edb938a0132a9948ed43eec0", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Replicate.olean", + "object_sha256": "403720b12a40c978b683f794cdf2b70f4ce559214e2fcb281dc4c28a9c03c55f", + "object_bytes": 302016, + "imports": [ + "Std.Tactic.BVDecide.Bitblast.BVExpr.Basic", + "Std.Sat.AIG.LawfulVecOperator" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Extract", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Extract.lean", + "source_sha256": "6f369b1e9cf9ad374d52a671ba505905a21f343e586a3eb67517b1abd116c7a1", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Extract.olean", + "object_sha256": "5736a754dba57c20a6471e3afbe9eedeb3ed1ebc65d72f549c51a0fa5024fa3e", + "object_bytes": 281376, + "imports": [ + "Std.Tactic.BVDecide.Bitblast.BVExpr.Basic", + "Std.Sat.AIG.LawfulVecOperator" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateLeft", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/RotateLeft.lean", + "source_sha256": "6d4ab6840946fb45b75cde4cd6fca38896ef49831d1a6eede4ca6ec7daf23e39", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/RotateLeft.olean", + "object_sha256": "dced7bf5d1de442064c97f582b3a86f3da123b5f1a9cdbe85cf755e61e5054f6", + "object_bytes": 285976, + "imports": [ + "Std.Tactic.BVDecide.Bitblast.BVExpr.Basic", + "Std.Sat.AIG.CachedGatesLemmas", + "Std.Sat.AIG.LawfulVecOperator" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateRight", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/RotateRight.lean", + "source_sha256": "6c49ba000ccc40fb8a635cb248f2ee5dc4f50aaa42b55fa397c1a6056718c8c6", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/RotateRight.olean", + "object_sha256": "95a30ff9076c0250a899567734f4019839631586c7c27960b3b363313a6ae426", + "object_bytes": 278392, + "imports": [ + "Std.Tactic.BVDecide.Bitblast.BVExpr.Basic", + "Std.Sat.AIG.CachedGatesLemmas", + "Std.Sat.AIG.LawfulVecOperator" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Mul", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Mul.lean", + "source_sha256": "326c0283ea4b84cf9d89f5a834a7c1ea763c8c0ac07f70c4e0b1c503f56f4e94", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Mul.olean", + "object_sha256": "a813f4634038d0bbcd94f7b30c64ea837f6cbea3018802c514dca5d40c46db06", + "object_bytes": 736440, + "imports": [ + "Std.Tactic.BVDecide.Bitblast.BVExpr.Basic", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Const" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Neg", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Neg.lean", + "source_sha256": "b3dd204414129efec99dfad283926669b0d32ae9a818d8647e36e5477575ba1b", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Neg.olean", + "object_sha256": "3e8254b0424f0c77b9246ee6bf94abad0b64bd132ea7a812c65fe51d7d83f94a", + "object_bytes": 69416, + "imports": [ + "Std.Tactic.BVDecide.Bitblast.BVExpr.Basic", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Not", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Const" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Sub", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Sub.lean", + "source_sha256": "d40a2d6d432111a8f3f40a802f490dba0a1f62511715dd7c6b7078c7b4c1deb1", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Sub.olean", + "object_sha256": "f920151529fa500b9f75ba19d0bfc1e935f628cb1b4dd1c1b5caa71a482d88b5", + "object_bytes": 69424, + "imports": [ + "Std.Tactic.BVDecide.Bitblast.BVExpr.Basic", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Neg" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ZeroExtend", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/ZeroExtend.lean", + "source_sha256": "64a5c40b4ac7ed672b5359b3ee7854250ff02a28e984eddc89c4e396d746ba0d", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/ZeroExtend.olean", + "object_sha256": "62a7d9c7866292a9795f5754b80b2bf7ce163014bfe815c4ce2d3d05725a5bbe", + "object_bytes": 552888, + "imports": [ + "Std.Tactic.BVDecide.Bitblast.BVExpr.Basic", + "Std.Sat.AIG.CachedGatesLemmas", + "Std.Sat.AIG.LawfulVecOperator" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Udiv", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Udiv.lean", + "source_sha256": "56823582a44ecd1729638cc9bbd54cd58a0c7a8d1e6aa5a4fdd59e79c4532fce", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Udiv.olean", + "object_sha256": "88f326027009e32676cf7a069d474c6dbc985ff7d66501df20aff1f40c1b1036", + "object_bytes": 1269024, + "imports": [ + "Std.Tactic.BVDecide.Bitblast.BVExpr.Basic", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Sub", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Eq", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Ult", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ZeroExtend", + "Std.Sat.AIG.If" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Umod", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Umod.lean", + "source_sha256": "ed4701e556d4fc8f49d8eb18e52882a1565f1472f456ac01bfc89ae91f523a86", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Umod.olean", + "object_sha256": "c051280233b1467e7388a7f5a4d29bc4677fbb0560f14a0477a6d8a6743ae4f5", + "object_bytes": 189424, + "imports": [ + "Std.Tactic.BVDecide.Bitblast.BVExpr.Basic", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Udiv" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Reverse", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Reverse.lean", + "source_sha256": "85f36bb0f197509dc3bbc9663b400ec8526d1a4fb18cfdd9ba92c523ff0ee2c0", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Reverse.olean", + "object_sha256": "5efeb505adebd2a4c2da281832796a7900e89fde2fe5f238069365705a821e56", + "object_bytes": 71984, + "imports": [ + "Std.Tactic.BVDecide.Bitblast.BVExpr.Basic", + "Std.Sat.AIG.LawfulVecOperator" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Expr.lean", + "source_sha256": "b6b5bb2f2e4ac1578c069dd5daf501184f8f0c2ed2dfa74ee6c6748e59aba143", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Expr.olean", + "object_sha256": "da17995402cceefeeb808032b0c483dab19b9743254b5b5c494b068668e25af4", + "object_bytes": 4018904, + "imports": [ + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Var", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Const", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Not", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftRight", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Append", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Replicate", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Extract", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateLeft", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateRight", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Mul", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Udiv", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Umod", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Reverse" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Pred", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Pred.lean", + "source_sha256": "16f94addb05e00f9ccc8e2e143d9c0ff164befc7e2db6ad21cf4451cd410e618", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Pred.olean", + "object_sha256": "fe0500e83129b5868b99b8db036c6240f3674b86dbaee862754a4fe7a834b1e4", + "object_bytes": 300480, + "imports": [ + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Eq", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Ult", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.GetLsbD", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Substructure", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Substructure.lean", + "source_sha256": "dbdbc1d7293d1afb5b2bf1af8c95fab4ffff2b7cc9bae09da198de4397ca8620", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Substructure.olean", + "object_sha256": "a635d310d7c86909a44f8f377e2b42f8c2597dda990197f66529c2520efb742f", + "object_bytes": 334000, + "imports": [ + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Pred" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl.lean", + "source_sha256": "ecd9ecf0d23015e4cceb3c0e7afc86406260d40ebf98c2ec8c029c3e6fcea3e6", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl.olean", + "object_sha256": "63c51a3b3126acc8486a8869c78b90537d4119a71b20459f2cf2b22deee26877", + "object_bytes": 18624, + "imports": [ + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Substructure" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Basic", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Basic.lean", + "source_sha256": "5aae2384380428041bbe79339ce47275ec8fbaf9f7beb9bf8900c54b8b9e4fb2", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Basic.olean", + "object_sha256": "f78690911ec0641ffd02e1b30c6c273d4f83f343044bcd424eaf991a86ca3a29", + "object_bytes": 28528, + "imports": [ + "Std.Sat.AIG.Basic", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Basic" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Eq", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Eq.lean", + "source_sha256": "2767eef82d9358c7ff182010f76e1579a887b24a6a4880be348012d4561d2c22", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Eq.olean", + "object_sha256": "3970042ee0d892e88b4c1bbcb099f2e705d8ec3f73b2b09349a3819fbdfffec6", + "object_bytes": 59904, + "imports": [ + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Basic", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Eq" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Add", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Add.lean", + "source_sha256": "e497186dc073e643dfe3bd64ca3350c71bf3e2fef78262c3040f62ea54a9f607", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Add.olean", + "object_sha256": "39f5d678c988453a7a9e485f1c00d2da281d4dccae67265a840ada3b74e750b0", + "object_bytes": 1797592, + "imports": [ + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Basic", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Carry", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Carry.lean", + "source_sha256": "5ecccf60651ccd5dfcdf926406d4142799d8748b2eb6f572daccd06c6ca37ce3", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Carry.olean", + "object_sha256": "fad75ab2e6630c88115b8ccfc72c17e92495893ce643a7d6d103a6d7a73f23d6", + "object_bytes": 712960, + "imports": [ + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Basic", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Add", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Carry" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Not", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Not.lean", + "source_sha256": "ad8380869a5ee982e08279b23f50c0fb763920fad777ff38f12a68a4358dad75", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Not.olean", + "object_sha256": "097962e33f1814903966c22fa1f8b26953927abb068781e40e97103c74490cc2", + "object_bytes": 32360, + "imports": [ + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Basic", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Not" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Ult", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Ult.lean", + "source_sha256": "68a4d3b5eed46e5a2971548368cfc6f7082c00849d6ab397b0f5bdedee7e302d", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Ult.olean", + "object_sha256": "d36eaa10d3419924f8199fa42eb1f6e4807e9dd96c873c944aae78c6d95c7ae2", + "object_bytes": 83896, + "imports": [ + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Basic", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Carry", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Not", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Ult" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.GetLsbD", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/GetLsbD.lean", + "source_sha256": "fe724d8f710f55d276a06ab3f5315e3b70a77b4b5a614745be0a00d725c2b89d", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/GetLsbD.olean", + "object_sha256": "8b2a56ebf2a3a0ce4ee32fc39024f55cfd9e4a9b4377c2d32900ffd920b5e841", + "object_bytes": 72720, + "imports": [ + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Basic", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.GetLsbD" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Const", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Const.lean", + "source_sha256": "dcee654dfac918670f108682366b2ef22bb3ade6c5e7a20a3e24d5acfe542938", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Const.olean", + "object_sha256": "627a8359d765e51ae46c5a8d486e61af040e573693dfe0c2f1cb2dd40f0d9ee9", + "object_bytes": 391800, + "imports": [ + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Basic", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Const" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Var", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Var.lean", + "source_sha256": "c625b904435859c197b49d602571c0be2aad62590b7adf0720faeb68d8daf683", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Var.olean", + "object_sha256": "bb7ff43b668d4fac3bfd3e5a8b47a96b8f7c720499716a82a808fc60d09255c1", + "object_bytes": 354368, + "imports": [ + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Basic", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Var" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftLeft", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/ShiftLeft.lean", + "source_sha256": "9c3884568c097d51d7b91c93cd5b5fc4f83c25ff36932ecbbf6222b8a4d0cc99", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/ShiftLeft.olean", + "object_sha256": "145d8d155cb14ff831fe9d64c3eedfd1d370c1009a42135273059bc790e2c0a6", + "object_bytes": 1148512, + "imports": [ + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Basic", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftRight", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/ShiftRight.lean", + "source_sha256": "0baa2f2e9d5bba910f14ec950efd8ae58b087528c751ba1b8fb9a4be7127e55b", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/ShiftRight.olean", + "object_sha256": "83d30d00e6ea9c61bf6f58b72e375de53829ecc1f92f523c9ea52923e4889bbf", + "object_bytes": 1555312, + "imports": [ + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Basic", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftRight" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Append", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Append.lean", + "source_sha256": "01880f4db292becaf9830a5ac3666b4d9d58425ab6ba5cb3f67df77987fe4f6c", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Append.olean", + "object_sha256": "0e721e31fa0751888238d57eb1cca998f52de9c2b2bec26a1c8370de27c5a007", + "object_bytes": 115480, + "imports": [ + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Basic", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Append" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Replicate", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Replicate.lean", + "source_sha256": "121261f3cd4bd45f929ab723cba6c4af9d042ab4afe6f319578e2b3a8521ed4d", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Replicate.olean", + "object_sha256": "a6d98c7823cb0f603f237a587da907270c88b9f564a11bdb17101d868b761523", + "object_bytes": 329424, + "imports": [ + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Basic", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Replicate" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Extract", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Extract.lean", + "source_sha256": "6af08aba5aa67b58d779452a2761539f3c177e9ad6e2e803908751c3d67e7d77", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Extract.olean", + "object_sha256": "2a8d41fab2333383743ce0b965576039d7b89fe33c7a3790e31affe7ac66d3b8", + "object_bytes": 305104, + "imports": [ + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Basic", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Extract" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateLeft", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/RotateLeft.lean", + "source_sha256": "0687775e8d33e423ee23a6d88dc192dac79913d7ed8734592410bba63c538737", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/RotateLeft.olean", + "object_sha256": "c50b557c06467632491db3b4b81eecb8fb10553cafa976144a29d412e7da72f5", + "object_bytes": 394144, + "imports": [ + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Basic", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateLeft" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateRight", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/RotateRight.lean", + "source_sha256": "c7cf25ea4b75ce6ffe5b507d429c873a85e785d1f8a3a150b5e41f586bec02b9", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/RotateRight.olean", + "object_sha256": "2aeaef58aa6b0b6ef6c18611381b8522ad27f6572359d19df7c6ab205f2cad0d", + "object_bytes": 398288, + "imports": [ + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Basic", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateRight" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Mul", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Mul.lean", + "source_sha256": "fe532ac2139e32f6d472951b36254f12a34cacfdf0173417172c16b0fea8252f", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Mul.olean", + "object_sha256": "8016d31aa590f94ec789732498868ce8eda5cacfb4e4a5525f8c9cc3ee402474", + "object_bytes": 929064, + "imports": [ + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Basic", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Add", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftLeft", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Const", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Mul" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Neg", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Neg.lean", + "source_sha256": "d5ea7eaa26e91756168dfc0b264a0a3e44242ef7e2e23ec460b97447c8abc853", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Neg.olean", + "object_sha256": "2733ef01593a014a12dd453a47d1f2d081e37dfdb9d0afb6b08d0de572f8aea4", + "object_bytes": 70208, + "imports": [ + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Basic", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Const", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Neg", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Not", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Add" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Sub", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Sub.lean", + "source_sha256": "c4b8e25b644400321d98351c22a1c3fc81da235ffbaab8816cf1898e194772e0", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Sub.olean", + "object_sha256": "bd437ac19da9dbfc44ff93fcc75652fe723784e61dc8002c5b9a58fc84120e8d", + "object_bytes": 65552, + "imports": [ + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Basic", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Neg", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Sub" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ZeroExtend", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/ZeroExtend.lean", + "source_sha256": "b9f706274a9bd6a1bb3caf5e8ca2d15693b9f513d755fe3844efa7c417a5fc7f", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/ZeroExtend.olean", + "object_sha256": "b4ddcae0143ff55d359b8fc6151bf951faa963cbbe7856c115160315ab294bce", + "object_bytes": 568944, + "imports": [ + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Basic", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ZeroExtend" + ] + }, + { + "module": "Std.Tactic.BVDecide.Normalize.Bool", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Normalize/Bool.lean", + "source_sha256": "a39cf7e1599cf0a12a5da1c47529f31fa18a55aa044cd295855807b6592a7d56", + "object_path": "lib/lean/Std/Tactic/BVDecide/Normalize/Bool.olean", + "object_sha256": "805687deb2586ea17f2899608be4590c69fe971a27aed3fa961373b5f0f5e164", + "object_bytes": 247600, + "imports": [ + "Init.SimpLemmas", + "Init.Data.Bool", + "Init.Data.BitVec.Lemmas" + ] + }, + { + "module": "Std.Tactic.BVDecide.Normalize.Canonicalize", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Normalize/Canonicalize.lean", + "source_sha256": "9b3b65c36e8093c43cf9047373214c88ae8734ccc3ea538066c88780a3f39240", + "object_path": "lib/lean/Std/Tactic/BVDecide/Normalize/Canonicalize.olean", + "object_sha256": "9067f0a2a1dbe42882c382d214257a6af04034253a517b8d1a609898c50bea86", + "object_bytes": 78896, + "imports": [ + "Init.Data.BitVec", + "Std.Tactic.BVDecide.Syntax" + ] + }, + { + "module": "Std.Tactic.BVDecide.Normalize.BitVec", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Normalize/BitVec.lean", + "source_sha256": "3b941306ad34a94d017c88a38e4076feae11ef49eb8322a16b920992b8eb3a96", + "object_path": "lib/lean/Std/Tactic/BVDecide/Normalize/BitVec.olean", + "object_sha256": "b2254235ad8659066bc0936c1f39b05901bd8c2ec68b983684670f5b82ee6258", + "object_bytes": 480184, + "imports": [ + "Init.Data.BitVec.Bitblast", + "Init.Data.AC", + "Std.Tactic.BVDecide.Normalize.Bool", + "Std.Tactic.BVDecide.Normalize.Canonicalize", + "Init.Data.SInt.Basic" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Udiv", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Udiv.lean", + "source_sha256": "f1a8536f61b070eb58295c8deb49e7fc2fca878a1b6ebbb69b707a70dc2aa13a", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Udiv.olean", + "object_sha256": "fa481b56490d8bf500040186af34948524c69dd71907bf7533be109e5396c028", + "object_bytes": 1098816, + "imports": [ + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Basic", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Const", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Sub", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ZeroExtend", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Eq", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Ult", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.GetLsbD", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Udiv", + "Std.Tactic.BVDecide.Normalize.BitVec" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Umod", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Umod.lean", + "source_sha256": "90df9a5a9918ce2b514db4a5dbfc29e522c613058b13bd9b0298ec3d5a1c43de", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Umod.olean", + "object_sha256": "1451bee4645e961086408b29c413b0f97f3d98999e6faa386aebc4868a4b3b4f", + "object_bytes": 417928, + "imports": [ + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Udiv", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Umod" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Reverse", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Reverse.lean", + "source_sha256": "2bf64a5cba62e54ab44ed363be5b0d99425e2a629c5bf91d57dba6f87f0d1b09", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Reverse.olean", + "object_sha256": "9b89f1b4b59f3f6764c1544bcff366ee6ed6edba0a391fe64c08b5d20072b074", + "object_bytes": 73976, + "imports": [ + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Basic", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Reverse" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Expr", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Expr.lean", + "source_sha256": "de494e378bbefcb78a45d989fd14a51d117ad1dfa9a66a6b9490afbf6f454541", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Expr.olean", + "object_sha256": "a97cd6ad320961d6802b44201d1472494d6ad254395141c4839d14c68181adcf", + "object_bytes": 3436184, + "imports": [ + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Basic", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Const", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Var", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Not", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftLeft", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftRight", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Add", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Append", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Replicate", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Extract", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateLeft", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateRight", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Mul", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Udiv", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Umod", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Reverse", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Pred", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Pred.lean", + "source_sha256": "040c0ce5fa657ef3a8ef6227be7dac0a5d2afa3879cbb1362b87e9051a1e5b54", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Pred.olean", + "object_sha256": "a74ebfa35e5d320cc063c1ab1e6c53a4443d5dcadac5df21afefb85866cb207c", + "object_bytes": 193304, + "imports": [ + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Eq", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Ult", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.GetLsbD", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Expr", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Pred" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas.lean", + "source_sha256": "3c792bdcafee1f9129d97c41e7008d619bd3b13cb379fd4702b0127bc18ac6ed", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas.olean", + "object_sha256": "6ed7b1664abdc210ca96bda171e965183319d9d27b35404a613e120102319842", + "object_bytes": 119160, + "imports": [ + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Pred" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit.lean", + "source_sha256": "13421f3dfbd594da94bef1d80526ba620ea3ec421da4df4259db8db1be653de1", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit.olean", + "object_sha256": "7321459883db4bc108a92559bba11e27384be279ef7cbf952847620063dfaad4", + "object_bytes": 18792, + "imports": [ + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast.BVExpr", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast/BVExpr.lean", + "source_sha256": "dfb2c464f1da85b539164e4f6a0e314380a320c140fbe1b3643e5479745f9f68", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr.olean", + "object_sha256": "04138869e9ad627e8aa39bee4b2a959b7cf6b33fbbc62f9bdad11a803d4ee354", + "object_bytes": 18488, + "imports": [ + "Std.Tactic.BVDecide.Bitblast.BVExpr.Basic", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit" + ] + }, + { + "module": "Std.Tactic.BVDecide.Bitblast", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Bitblast.lean", + "source_sha256": "4b695f19097de26ad28db58e9ab1008e7c5ac063caa88861a2c4cae7438920bf", + "object_path": "lib/lean/Std/Tactic/BVDecide/Bitblast.olean", + "object_sha256": "e608d9eca5096b5c711048ed4fc7c51bc2bb072b5edd39f5a663cb4a3fbb9a9a", + "object_bytes": 18600, + "imports": [ + "Std.Tactic.BVDecide.Bitblast.BoolExpr", + "Std.Tactic.BVDecide.Bitblast.BVExpr" + ] + }, + { + "module": "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/Reflect.lean", + "source_sha256": "9d83f89ac4320ad899269043c571965e0396d6f85f7a364da09aca656c456d63", + "object_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/Reflect.olean", + "object_sha256": "ed89c65cc95da1d98fedc9530f98a42afbb547bc9ec1a5eb184d6ba1a71328bb", + "object_bytes": 1152128, + "imports": [ + "Std.Data.HashMap", + "Std.Tactic.BVDecide.Bitblast.BVExpr.Basic", + "Lean.Meta.AppBuilder", + "Lean.ToExpr", + "Lean.Data.RArray" + ] + }, + { + "module": "Std.Tactic.BVDecide.LRAT.Internal.Entails", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/LRAT/Internal/Entails.lean", + "source_sha256": "fc9901dc1f67835345c353a7086614aafc270e941dde4f089d3976b6c8c7a824", + "object_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Entails.olean", + "object_sha256": "e2f6579a30c0361e8e3f33a0d2e2fbd1165034ba9fe789171ec09684421d377a", + "object_bytes": 179984, + "imports": [ + "Init.NotationExtra", + "Init.PropLemmas" + ] + }, + { + "module": "Std.Tactic.BVDecide.LRAT.Internal.PosFin", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/LRAT/Internal/PosFin.lean", + "source_sha256": "a91efb550af75741afd415aac730c5ddfe70681c5ed460fc8167c32d0ec61b4d", + "object_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/PosFin.olean", + "object_sha256": "b24abbeaadf8eab8321834fc7962eb08b6d6d3aafb422e9ce84e5565db693f98", + "object_bytes": 36208, + "imports": [ + "Init.NotationExtra", + "Init.Data.Hashable" + ] + }, + { + "module": "Std.Tactic.BVDecide.LRAT.Internal.Assignment", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/LRAT/Internal/Assignment.lean", + "source_sha256": "7853413a2f6c54cba13a4bc6810fbee2b30443d04ed3a726b75353e7566f930f", + "object_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Assignment.olean", + "object_sha256": "a0b4296cc37d2351b67eb3428a97c6fd041a426d50e3c2a22ec1ed7c0f1ec1e6", + "object_bytes": 231248, + "imports": [ + "Init.ByCases", + "Std.Tactic.BVDecide.LRAT.Internal.Entails", + "Std.Tactic.BVDecide.LRAT.Internal.PosFin" + ] + }, + { + "module": "Std.Tactic.BVDecide.LRAT.Internal.Clause", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/LRAT/Internal/Clause.lean", + "source_sha256": "ad291d59542a98c1b31760c1ffe6f2eab086d7490a513a8ada73ba49576a40c5", + "object_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Clause.olean", + "object_sha256": "04bafe40cd396a755c52546c7486d5b99fe9ad1c7061d40bbcd03f306d498d23", + "object_bytes": 845992, + "imports": [ + "Init.Data.List.Erase", + "Init.Data.Array.Lemmas", + "Std.Data.HashMap", + "Std.Sat.CNF.Basic", + "Std.Tactic.BVDecide.LRAT.Internal.PosFin", + "Std.Tactic.BVDecide.LRAT.Internal.Assignment" + ] + }, + { + "module": "Std.Tactic.BVDecide.LRAT.Internal.Formula.Class", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/Class.lean", + "source_sha256": "d04a83b9072e48fbc724aa9d89c8039ed1443e1cec1a57ef7edac7c1695157d7", + "object_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/Class.olean", + "object_sha256": "f16e76f7cd13fc80150220d18159385665de30616317844568f4cf17a43ef7c0", + "object_bytes": 147008, + "imports": [ + "Std.Tactic.BVDecide.LRAT.Internal.Entails", + "Std.Tactic.BVDecide.LRAT.Internal.Clause" + ] + }, + { + "module": "Std.Tactic.BVDecide.LRAT.Internal.Formula.Implementation", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/Implementation.lean", + "source_sha256": "f91931bd372d3e3070c4bf789df56dab3146784fb10671b869ba82939dbe453a", + "object_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/Implementation.olean", + "object_sha256": "60aca3802e338fab5953e77f6debe5f48572651196394d40c5f2b1fc7f5bb4a0", + "object_bytes": 692632, + "imports": [ + "Std.Tactic.BVDecide.LRAT.Internal.Formula.Class", + "Std.Tactic.BVDecide.LRAT.Internal.Assignment", + "Std.Sat.CNF.Basic" + ] + }, + { + "module": "Std.Tactic.BVDecide.LRAT.Internal.CNF", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/LRAT/Internal/CNF.lean", + "source_sha256": "494496fc7df8fbd4a8d0acb97863b543c98d906d1e5bc13e0447c7cb4da3e4ce", + "object_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/CNF.olean", + "object_sha256": "fb90467d408567d4b1a7a5981f99b9e3c5eadfab1ab2c5f305c0b16c0b0d7426", + "object_bytes": 169992, + "imports": [ + "Std.Tactic.BVDecide.LRAT.Internal.Formula.Class" + ] + }, + { + "module": "Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/Lemmas.lean", + "source_sha256": "499a89f4b046f5371700c313551fdf11f86ea617c40090744f6e991f9eeade81", + "object_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/Lemmas.olean", + "object_sha256": "bb7445ae692135dc88c84da48839ec3287c275404ceaa81c5fcf34064d3e706a", + "object_bytes": 1041648, + "imports": [ + "Std.Tactic.BVDecide.LRAT.Internal.Formula.Implementation", + "Std.Tactic.BVDecide.LRAT.Internal.CNF" + ] + }, + { + "module": "Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RupAddResult.lean", + "source_sha256": "f5db054e6eb324070dc2442daa1b36513855354a00a2669a11e231e2448a7f72", + "object_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RupAddResult.olean", + "object_sha256": "fe7f98b9cf3ae3bbc55c6c99141c8f7af6c0e7b04def133d138e6d11115a9e11", + "object_bytes": 2359392, + "imports": [ + "Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas" + ] + }, + { + "module": "Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RupAddSound.lean", + "source_sha256": "ddac9dc341d2f8fa2fadc68d2f327ea5e33ab4dce1842b9ed0a6a386fe832a25", + "object_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RupAddSound.olean", + "object_sha256": "b3215b9ec7db0b53df7280c584d33ab577dfb1a41d1332e61832e1f514c3734d", + "object_bytes": 1499912, + "imports": [ + "Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult" + ] + }, + { + "module": "Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddResult", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RatAddResult.lean", + "source_sha256": "de589d29584ed400c9d03b3ebc029efd46e0212578236e79f3e660f1088520a5", + "object_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RatAddResult.olean", + "object_sha256": "fa6df9f44022196300e3c630720e17601b8c81418db8a7a728e00ba6b332d63f", + "object_bytes": 684176, + "imports": [ + "Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound" + ] + }, + { + "module": "Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddSound", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RatAddSound.lean", + "source_sha256": "a3e9d96a1929d0a137bad6cedb4baf42ed307ff303c4fbab5137d09adc3530e5", + "object_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RatAddSound.olean", + "object_sha256": "c549e99344a1a3ef2b6b46d4d20e5d17a9961eddea02eea6a5ad98ad17ddd4d2", + "object_bytes": 1375984, + "imports": [ + "Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddResult" + ] + }, + { + "module": "Std.Tactic.BVDecide.LRAT.Internal.Formula.Instance", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/Instance.lean", + "source_sha256": "8254c48a250b188e4b5b4fc86dde31878a26f23e187e2d232569fe82bc6e2935", + "object_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/Instance.olean", + "object_sha256": "1a8bf6a2580fbfc784cc472572cb02c4a5d6a759f3d403e49849a97115da802d", + "object_bytes": 47720, + "imports": [ + "Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddSound" + ] + }, + { + "module": "Std.Tactic.BVDecide.LRAT.Internal.Formula", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula.lean", + "source_sha256": "1d506c827d739bab39bc2756b987381583b0c3331dac25bd1454b6972179a1fb", + "object_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula.olean", + "object_sha256": "b43e8ba83360c145abc8bd467582417d7626c60c38eaf6a3c693321e3fbfe7a9", + "object_bytes": 19352, + "imports": [ + "Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas", + "Std.Tactic.BVDecide.LRAT.Internal.Formula.Class", + "Std.Tactic.BVDecide.LRAT.Internal.Formula.Implementation", + "Std.Tactic.BVDecide.LRAT.Internal.Formula.Instance", + "Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddResult", + "Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddSound", + "Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult", + "Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound" + ] + }, + { + "module": "Std.Tactic.BVDecide.LRAT.Internal.Convert", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/LRAT/Internal/Convert.lean", + "source_sha256": "9bd9da49fcf617655dff9e90ec01e55a953bc97c990d7a70be1cbf1b250445aa", + "object_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Convert.olean", + "object_sha256": "504c5d6438adc3442804cb65c02ab640a7f847117ec232c0075cb25132199065", + "object_bytes": 245712, + "imports": [ + "Std.Sat.CNF.RelabelFin", + "Std.Tactic.BVDecide.LRAT.Internal.Formula" + ] + }, + { + "module": "Std.Tactic.BVDecide.LRAT.Internal.LRATChecker", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/LRAT/Internal/LRATChecker.lean", + "source_sha256": "636a9e7bdd504233b7653fe4c52008c0dbde8aec092e68a687c220cbb5e74369", + "object_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/LRATChecker.olean", + "object_sha256": "b5b2d19a04d8750323de8eeaa7321c1865ca4a0720b9275c27a2596a567ab8fb", + "object_bytes": 122672, + "imports": [ + "Std.Tactic.BVDecide.LRAT.Actions", + "Std.Tactic.BVDecide.LRAT.Internal.Formula.Class" + ] + }, + { + "module": "Std.Tactic.BVDecide.LRAT.Internal.Actions", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/LRAT/Internal/Actions.lean", + "source_sha256": "ccde753c5d94287b8808d87298ba356c1b4f4baaf8a70ab98d2e996f42830eea", + "object_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Actions.olean", + "object_sha256": "f469fbf96001665c8b8ce9276ee4b1f3e57e3e45540b5c948c7cf01b2132667e", + "object_bytes": 172272, + "imports": [ + "Std.Tactic.BVDecide.LRAT.Actions", + "Std.Tactic.BVDecide.LRAT.Internal.Clause" + ] + }, + { + "module": "Std.Tactic.BVDecide.LRAT.Internal.LRATCheckerSound", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/LRAT/Internal/LRATCheckerSound.lean", + "source_sha256": "6aade745ca43d885b65a1ff3fc6a842dc5bf4767f5b257aca20460714e0be376", + "object_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/LRATCheckerSound.olean", + "object_sha256": "69df9d26e5b6bb3505c0e93c643fbfae4979fec0653af2f137d476a2f4df40df", + "object_bytes": 346744, + "imports": [ + "Std.Tactic.BVDecide.LRAT.Internal.LRATChecker", + "Std.Tactic.BVDecide.LRAT.Internal.CNF", + "Std.Tactic.BVDecide.LRAT.Internal.Actions" + ] + }, + { + "module": "Std.Tactic.BVDecide.LRAT.Checker", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/LRAT/Checker.lean", + "source_sha256": "13c34a03e65d829ec44fdf6665ebe5c38615a61505c3bd7bcd2773dded9d5e11", + "object_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Checker.olean", + "object_sha256": "91b2bed5c37a3c1ea3604ab8ca8c687ae41630c87559296d87e53bfd3794aa36", + "object_bytes": 207408, + "imports": [ + "Std.Tactic.BVDecide.LRAT.Actions", + "Std.Tactic.BVDecide.LRAT.Internal.Convert", + "Std.Tactic.BVDecide.LRAT.Internal.LRATChecker", + "Std.Tactic.BVDecide.LRAT.Internal.LRATCheckerSound", + "Std.Sat.CNF" + ] + }, + { + "module": "Std.Tactic.BVDecide.Reflect", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Reflect.lean", + "source_sha256": "165d5568a8d3a78c2d354492bc7a1169f27a9884a201d4bec47f884a9e882bd8", + "object_path": "lib/lean/Std/Tactic/BVDecide/Reflect.olean", + "object_sha256": "0c923e329363a6d86eeb505c53171c4cab9e88e9e1c61e3b19ee597564238b10", + "object_bytes": 267096, + "imports": [ + "Init.Data.BitVec", + "Std.Tactic.BVDecide.LRAT.Checker", + "Std.Tactic.BVDecide.LRAT.Parser", + "Std.Tactic.BVDecide.Bitblast", + "Std.Sat.AIG.CNF", + "Std.Sat.AIG.RelabelNat" + ] + }, + { + "module": "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVExpr", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/ReifiedBVExpr.lean", + "source_sha256": "3a34faabd96db9f92606e13c1bc09c51718898eeafd2019cddcd68a69c891d4a", + "object_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/ReifiedBVExpr.olean", + "object_sha256": "7fe5260ce7ff66ef670e201dd2e7a44766cafcc9f12814dc640ed4d645ba6d9f", + "object_bytes": 163304, + "imports": [ + "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect", + "Std.Tactic.BVDecide.Reflect" + ] + }, + { + "module": "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVPred", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/ReifiedBVPred.lean", + "source_sha256": "d184b055a78132cab9ed6639318af08cb17ab412a4d0fc3326d8f44eac20d7dc", + "object_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/ReifiedBVPred.olean", + "object_sha256": "777eeb14e32551ab3fa40a6cb5df844468a20bebac045b69f3bcc29be5082ba8", + "object_bytes": 182488, + "imports": [ + "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVExpr" + ] + }, + { + "module": "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVLogical", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/ReifiedBVLogical.lean", + "source_sha256": "9c133bc4566d030e18a3ffb46da228763fcfdb938ab74d1e4b29334334d73c2a", + "object_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/ReifiedBVLogical.olean", + "object_sha256": "1ecb89b9caac5f274491904d3fb800866525567e1f57224a6429325cbea18e4c", + "object_bytes": 244688, + "imports": [ + "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVPred" + ] + }, + { + "module": "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedLemmas", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/ReifiedLemmas.lean", + "source_sha256": "f346901781ba33f5feb1828baef2c2185fd48cb2ca6d288124db58fb716e74a2", + "object_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/ReifiedLemmas.olean", + "object_sha256": "f5553cb9c73b8a17396c59c2a86bc430421611ae48198758ba8678c64b0b0726", + "object_bytes": 150672, + "imports": [ + "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVLogical" + ] + }, + { + "module": "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reify", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/Reify.lean", + "source_sha256": "3bd77793f8a3afbecfa2292931f06102b50116230d742736b769f6ef9de05fe8", + "object_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/Reify.olean", + "object_sha256": "d74935cd766610b92420a573fa46cec6bad24ddf96d61395569973e3032eeaa7", + "object_bytes": 1009840, + "imports": [ + "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVLogical", + "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedLemmas" + ] + }, + { + "module": "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.SatAtBVLogical", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/SatAtBVLogical.lean", + "source_sha256": "803f21c08943d65614e152cd45a8e74034a4f2fe050848fcbfd6bf8db345840e", + "object_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/SatAtBVLogical.olean", + "object_sha256": "92a6392f02ac5defb35aeed688df43b30973054aaca77753fc59e6c948b46d7a", + "object_bytes": 191920, + "imports": [ + "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reify" + ] + }, + { + "module": "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Basic", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Basic.lean", + "source_sha256": "f652ec00d8895a1486ab80ec85327a6a5939a291a526fd366b3115712b577079", + "object_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Basic.olean", + "object_sha256": "f03b3e392dd44974af197d676fbc8cfb65d28a31a1d41d370ac30e943d50215f", + "object_bytes": 749304, + "imports": [ + "Lean.Meta.Basic", + "Lean.Elab.Tactic.BVDecide.Frontend.Attr" + ] + }, + { + "module": "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ApplyControlFlow", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/ApplyControlFlow.lean", + "source_sha256": "a305838b35105aeb99bd7569c28c62b6852a67149081b42548db8fb8d457be1a", + "object_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/ApplyControlFlow.olean", + "object_sha256": "f8333d79972602d59a23cf5a7a2cc6eeef8ca57131cbe077cc8365e98c916ff2", + "object_bytes": 265280, + "imports": [ + "Lean.Meta.Tactic.Simp" + ] + }, + { + "module": "Std.Tactic.BVDecide.Normalize.Equal", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Normalize/Equal.lean", + "source_sha256": "69586f61a1595357980dc28111676a51ef08b377d20cee8727e2cf802ef0b72e", + "object_path": "lib/lean/Std/Tactic/BVDecide/Normalize/Equal.olean", + "object_sha256": "fb5bc66f1af6a01c673c0e4979e1081619c14ec27e653dc1f28435f37bd1a96f", + "object_bytes": 149600, + "imports": [ + "Init.Data.Bool", + "Init.Data.BitVec" + ] + }, + { + "module": "Std.Tactic.BVDecide.Normalize.Prop", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Normalize/Prop.lean", + "source_sha256": "147963aa5dffb4b0385277c0d1b33abc740c3b76e557d306afc918dbe77232c3", + "object_path": "lib/lean/Std/Tactic/BVDecide/Normalize/Prop.olean", + "object_sha256": "03280fdf1490dc52c68f079b4a5f1cf1f9dc5420fc3fb97b141bb2c2fe4080dd", + "object_bytes": 27400, + "imports": [ + "Init.SimpLemmas" + ] + }, + { + "module": "Std.Tactic.BVDecide.Normalize", + "root": "lean", + "source_path": "src/lean/Std/Tactic/BVDecide/Normalize.lean", + "source_sha256": "dfa32b95153942ee63d2c2ee4e5a5b30767e65cbc90251ab9970fbd5c2248852", + "object_path": "lib/lean/Std/Tactic/BVDecide/Normalize.olean", + "object_sha256": "389fab03e5d50bc890ff84b5aeb36f57c65febfefca75e8e1c38d83c354887dc", + "object_bytes": 19000, + "imports": [ + "Std.Tactic.BVDecide.Normalize.BitVec", + "Std.Tactic.BVDecide.Normalize.Bool", + "Std.Tactic.BVDecide.Normalize.Canonicalize", + "Std.Tactic.BVDecide.Normalize.Equal", + "Std.Tactic.BVDecide.Normalize.Prop" + ] + }, + { + "module": "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Simproc.lean", + "source_sha256": "1bea45ab5d594f97e6e3f61b7260690e5ab25e63278f9831c40f28c5746d3644", + "object_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Simproc.olean", + "object_sha256": "fe8bf61b1a19d94b47b85189f2ab096be8b8066593f869452dc627b64ca21109", + "object_bytes": 2836872, + "imports": [ + "Std.Tactic.BVDecide.Normalize", + "Std.Tactic.BVDecide.Syntax", + "Lean.Elab.Tactic.Simp", + "Lean.Elab.Tactic.BVDecide.Frontend.Attr" + ] + }, + { + "module": "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Rewrite", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Rewrite.lean", + "source_sha256": "f4687d0944924aa1ac483499db25935c78844146690e0eb2826c19185d75e106", + "object_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Rewrite.olean", + "object_sha256": "117991b87e1d6f17acaeb4f9f33ee4241c5b6ab2b49164b21939878b989db1ef", + "object_bytes": 262944, + "imports": [ + "Lean.Elab.Tactic.Simp", + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Basic", + "Lean.Elab.Tactic.BVDecide.Frontend.Attr" + ] + }, + { + "module": "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AndFlatten", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/AndFlatten.lean", + "source_sha256": "5c297b29db5728dfa439c0fb753b6e40c95d6ada4f98fa90a51472568bd585cd", + "object_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/AndFlatten.olean", + "object_sha256": "2866396b1c4bd8abb29886c4f3d7264724c9659dc1a37f971de22ec968aba6f1", + "object_bytes": 357416, + "imports": [ + "Std.Tactic.BVDecide.Normalize.Bool", + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Basic", + "Lean.Meta.Tactic.Assert" + ] + }, + { + "module": "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.EmbeddedConstraint", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/EmbeddedConstraint.lean", + "source_sha256": "b208686d9ce0a837602e3a3f0f6061174c6d8d86c3e2c089c8e24ea99e9a28d4", + "object_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/EmbeddedConstraint.olean", + "object_sha256": "d99d5620652b6b8035132e64045e9482b06dde705360bd92251f0bbaeff7ad09", + "object_bytes": 247824, + "imports": [ + "Std.Tactic.BVDecide.Normalize.Bool", + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Basic", + "Lean.Meta.Tactic.Simp" + ] + }, + { + "module": "Lean.Meta.Tactic.AC.Main", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/AC/Main.lean", + "source_sha256": "0eba0a6dae0fb1bd238667d9177ac51a70c30655ae90d175a5e1eae484f130dd", + "object_path": "lib/lean/Lean/Meta/Tactic/AC/Main.olean", + "object_sha256": "92a99964c42299aa3a0067d5548c5aa8964c54768a882a961ceee7514e09ae67", + "object_bytes": 1482800, + "imports": [ + "Init.Data.AC", + "Lean.Meta.AppBuilder", + "Lean.Meta.Tactic.Refl", + "Lean.Meta.Tactic.Simp.Main", + "Lean.Elab.Tactic.Rewrite" + ] + }, + { + "module": "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AC", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/AC.lean", + "source_sha256": "a31c20ec7f83f63f87a5ac71862a4cbebad0eb1e434d3b88f88a6c2737dd7cfc", + "object_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/AC.olean", + "object_sha256": "70a55c0dca631a9e62c7b21342562d7251fc5620ab0083b852d2e04c870ee0c6", + "object_bytes": 1294336, + "imports": [ + "Lean.Meta.Tactic.AC.Main", + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Basic" + ] + }, + { + "module": "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.TypeAnalysis", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/TypeAnalysis.lean", + "source_sha256": "d6ab81683bb68b77035a977d25512d68a82d33c48cdb644ee012f108b135d187", + "object_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/TypeAnalysis.olean", + "object_sha256": "aafa986853606b7f2d4e4bbeca3b3e080770f269708ae693935dd14491354285", + "object_bytes": 1741240, + "imports": [ + "Init.Data.SInt.Basic", + "Std.Tactic.BVDecide.Normalize.BitVec", + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Basic" + ] + }, + { + "module": "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Structures", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Structures.lean", + "source_sha256": "1ae3a549e339ed2743466620653c90d517efae6a61cb986775d70b7b779fc702", + "object_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Structures.olean", + "object_sha256": "7db5227076c15fc0b70a0b1abc7f915af05cbe9b4e2aff54c5e3d5c1403fd98f", + "object_bytes": 332672, + "imports": [ + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Basic", + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ApplyControlFlow", + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.TypeAnalysis", + "Lean.Meta.Tactic.Cases", + "Lean.Meta.Tactic.Simp", + "Lean.Meta.Injective" + ] + }, + { + "module": "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.IntToBitVec", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/IntToBitVec.lean", + "source_sha256": "b1e867bc7fd154d8cf2005a04823b930e31623aeb2aa24c7b463fac9c50fafe6", + "object_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/IntToBitVec.olean", + "object_sha256": "31992c73b05c3ce84aaf4d513fa3c5cb4a4fa7d0de862103011b4d421d53be72", + "object_bytes": 1000992, + "imports": [ + "Init.Data.SInt.Basic", + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Basic", + "Lean.Elab.Tactic.BVDecide.Frontend.Attr", + "Lean.Elab.Tactic.Simp" + ] + }, + { + "module": "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Enums.lean", + "source_sha256": "3f45f6573742a8027e34651970d85f79b0899c3dec66729dfec589fff5c9e484", + "object_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Enums.olean", + "object_sha256": "894e1aca90c0f56272d040bdc206cb362d92344f22c40a70af1cc077b19e4d36", + "object_bytes": 1605936, + "imports": [ + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Basic", + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.TypeAnalysis", + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ApplyControlFlow", + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Structures", + "Lean.Meta.Tactic.Simp" + ] + }, + { + "module": "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ShortCircuit", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/ShortCircuit.lean", + "source_sha256": "ae07abac0568ccb0c04a5279413ad5ed36bea4447deb8d9baf3693c606b30b2c", + "object_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/ShortCircuit.olean", + "object_sha256": "b8d124dd48735c0d420237032021f1d7c4e9d5387d8b7f72dc30f2f44636ef34", + "object_bytes": 122880, + "imports": [ + "Lean.Elab.Tactic.Simp", + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Basic", + "Lean.Elab.Tactic.BVDecide.Frontend.Attr", + "Std.Tactic.BVDecide.Normalize.BitVec" + ] + }, + { + "module": "Lean.Elab.Tactic.BVDecide.Frontend.Normalize", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize.lean", + "source_sha256": "22accfd24b526eff3151f8036d8e7f1f52e4e1d8a516db661047d379f885ceb0", + "object_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize.olean", + "object_sha256": "940d78c36447b6e5258537db22e3121070ee03e2a793eb0b82b17af6d3f937ce", + "object_bytes": 391752, + "imports": [ + "Lean.Elab.Tactic.FalseOrByContra", + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Basic", + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ApplyControlFlow", + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc", + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Rewrite", + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AndFlatten", + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.EmbeddedConstraint", + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AC", + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Structures", + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.IntToBitVec", + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums", + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.TypeAnalysis", + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ShortCircuit" + ] + }, + { + "module": "Lean.Elab.Tactic.BVDecide.Frontend.LRAT", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/BVDecide/Frontend/LRAT.lean", + "source_sha256": "b49b3b1db398d52008da21e22272407cc2f9344d852e99bc9e05d0ab2c23ea9d", + "object_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/LRAT.olean", + "object_sha256": "b546941cf970acb03a2f4d93a544539d6f791db54abb4ab8e6a7d7f7190a3b4d", + "object_bytes": 612456, + "imports": [ + "Lean.Elab.Tactic.BVDecide.Frontend.Attr", + "Lean.Elab.Tactic.BVDecide.LRAT.Trim", + "Lean.Elab.Tactic.BVDecide.External", + "Std.Tactic.BVDecide.LRAT.Checker", + "Std.Sat.CNF.Dimacs" + ] + }, + { + "module": "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide.lean", + "source_sha256": "42b99fa958974774cdf5dc119b7e2fdf481a5e8729ced2e42ab364251e9d305b", + "object_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide.olean", + "object_sha256": "d7277cf79b737323db92704ee3a3d4910585ade26efe8070d3c71453eac8de70", + "object_bytes": 2497176, + "imports": [ + "Std.Sat.AIG.CNF", + "Std.Sat.AIG.RelabelNat", + "Std.Tactic.BVDecide.Bitblast", + "Std.Tactic.BVDecide.Syntax", + "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.SatAtBVLogical", + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize", + "Lean.Elab.Tactic.BVDecide.Frontend.LRAT" + ] + }, + { + "module": "Lean.Elab.Tactic.BVDecide.Frontend.BVCheck", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVCheck.lean", + "source_sha256": "f70e945945aefc1f0dc60556cee82deb40e135f7109633d5a76b5e60714aebb7", + "object_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVCheck.olean", + "object_sha256": "239d6e305b55544d1f7c206a080ecb754a270109c479c0eaf893cc3d69dce6c3", + "object_bytes": 211928, + "imports": [ + "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide", + "Lean.Meta.Tactic.TryThis", + "Std.Tactic.BVDecide.Syntax" + ] + }, + { + "module": "Lean.Elab.Tactic.BVDecide.Frontend.BVTrace", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVTrace.lean", + "source_sha256": "ddc94324dd06d01d9cbf98d2d6b4093521595e5b9c5c7444f77fdc57b3c9841a", + "object_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVTrace.olean", + "object_sha256": "c617d95e070d7db020c33beb5da9f9f88f95c6afbb19accc1f9369334acae0f6", + "object_bytes": 248040, + "imports": [ + "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide", + "Lean.Elab.Tactic.BVDecide.Frontend.BVCheck", + "Lean.Elab.Tactic.BVDecide.LRAT.Trim", + "Lean.Meta.Tactic.TryThis", + "Std.Tactic.BVDecide.Syntax" + ] + }, + { + "module": "Lean.Elab.Tactic.BVDecide.Frontend", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/BVDecide/Frontend.lean", + "source_sha256": "ba83bf22b9157f5775c27cd26c5e0c03584f8ab67555a92bbf9fcfee1cdafe47", + "object_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend.olean", + "object_sha256": "32dcffca90a8945aaf5d69dbd663b8d91eb1056391a71558cf1ed850ec322aec", + "object_bytes": 18784, + "imports": [ + "Lean.Elab.Tactic.BVDecide.Frontend.Attr", + "Lean.Elab.Tactic.BVDecide.Frontend.BVCheck", + "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide", + "Lean.Elab.Tactic.BVDecide.Frontend.BVTrace", + "Lean.Elab.Tactic.BVDecide.Frontend.LRAT", + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize" + ] + }, + { + "module": "Lean.Elab.Tactic.BVDecide", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/BVDecide.lean", + "source_sha256": "20df828959759822a0b85d2527e48c38b882a165986bd9b8736e924d1f75e9d3", + "object_path": "lib/lean/Lean/Elab/Tactic/BVDecide.olean", + "object_sha256": "20406fe70f6cde4987af52872fcebd09a4e11b029e22dab48eff104359806d40", + "object_bytes": 22360, + "imports": [ + "Lean.Elab.Tactic.BVDecide.LRAT", + "Lean.Elab.Tactic.BVDecide.External", + "Lean.Elab.Tactic.BVDecide.Frontend" + ] + }, + { + "module": "Lean.Elab.Tactic.BoolToPropSimps", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/BoolToPropSimps.lean", + "source_sha256": "d5b86fb2283c9ac321fa6ccd9cc4a4c1e16efebefddfac60db9a5b0ef4e5d6b7", + "object_path": "lib/lean/Lean/Elab/Tactic/BoolToPropSimps.olean", + "object_sha256": "cbe35ebea1b425b365d44a259281a164d22278a6393366785ae2e6d28a7f2c9a", + "object_bytes": 29864, + "imports": [ + "Lean.Meta.Tactic.Simp.Attr" + ] + }, + { + "module": "Lean.Elab.Tactic.Classical", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/Classical.lean", + "source_sha256": "59113783d99862364d9411ecb96a97a0721885bd7d551faf6065e9c05458ac33", + "object_path": "lib/lean/Lean/Elab/Tactic/Classical.olean", + "object_sha256": "660bc6a287c928af3c04b661d8ed1de6c210337166cb820205983423ec429174", + "object_bytes": 233472, + "imports": [ + "Lean.Elab.Tactic.Basic" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Util", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Util.lean", + "source_sha256": "e800ebf49000210d3e4bd6accbb428045069a722b6fe0cc38d68907c1bd3e84f", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Util.olean", + "object_sha256": "f49adaacccccff62cf3bc287e516acfa6299c0df80df465f3fc7c6cb67dc3f8a", + "object_bytes": 757352, + "imports": [ + "Init.Simproc", + "Init.Grind.Tactics", + "Lean.Meta.AbstractNestedProofs", + "Lean.Meta.Transform", + "Lean.Meta.Tactic.Util", + "Lean.Meta.Tactic.Clear", + "Lean.Meta.Tactic.Simp.Simproc" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.EMatchTheorem", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/EMatchTheorem.lean", + "source_sha256": "f345fb6601612eb1c0be7e84b177e737f7bf18893d003f3e5bff0362318336f4", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/EMatchTheorem.olean", + "object_sha256": "9258925f875ca66e4bf094c99dfa7b4b95d7d0deda46f3973d023f6f0b9ae607", + "object_bytes": 4115416, + "imports": [ + "Init.Grind.Util", + "Init.Grind.Tactics", + "Lean.HeadIndex", + "Lean.PrettyPrinter", + "Lean.Util.FoldConsts", + "Lean.Util.CollectFVars", + "Lean.Meta.Basic", + "Lean.Meta.InferType", + "Lean.Meta.Eqns", + "Lean.Meta.Match.MatchEqs", + "Lean.Meta.Tactic.Grind.Util" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Cases", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Cases.lean", + "source_sha256": "1d9d89dab7b808b43364d0c05ce1f053d7e30eb2363029c58ce9e12f7320a567", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Cases.olean", + "object_sha256": "572d093199951e6cd3b95349560b9c9288821cffdebcfcebf29e84e4db0f7f5d", + "object_bytes": 736368, + "imports": [ + "Lean.Meta.Tactic.Cases" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.ExtAttr", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/ExtAttr.lean", + "source_sha256": "dda0836c033755d3015011928c1f18974bf7e4f6190e56d3641818f34d45fc8e", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/ExtAttr.olean", + "object_sha256": "ec7ac866ca4a3a28b6d7a3b76fb34ce86b37271d3222a8116173f15e2cc8b5b8", + "object_bytes": 130512, + "imports": [ + "Lean.Meta.Tactic.Ext" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Attr", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Attr.lean", + "source_sha256": "baefa8703d838d7a7b1907b163dc7582a5d444b479f4164d3865ab67599c114b", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Attr.olean", + "object_sha256": "d57d80dadc72a884a67b177244245235e597ae35cf339fc61e6ce7ac359dbbe4", + "object_bytes": 486208, + "imports": [ + "Lean.Meta.Tactic.Grind.EMatchTheorem", + "Lean.Meta.Tactic.Grind.Cases", + "Lean.Meta.Tactic.Grind.ExtAttr" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.RevertAll", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/RevertAll.lean", + "source_sha256": "e78cdfaf84e7f15f493b2ee815d4024812a3508d92dbc896f0e6230e9b172e4a", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/RevertAll.olean", + "object_sha256": "c68f1a2683dfc1922d5b8dadf8c54a6f434c223f12531427b15109aff2c8bf8b", + "object_bytes": 75328, + "imports": [ + "Lean.Meta.Tactic.Revert" + ] + }, + { + "module": "Std.Data.TreeSet.Basic", + "root": "lean", + "source_path": "src/lean/Std/Data/TreeSet/Basic.lean", + "source_sha256": "c62157ba7b3e2a9b748a6d59e9b76958857354400f6f4b6ee3a6b918e9fa4970", + "object_path": "lib/lean/Std/Data/TreeSet/Basic.olean", + "object_sha256": "b4eae21515a043f3ddcf412c122a2b694b0d0ad9a77d404ab71da03cfbcee7be", + "object_bytes": 1138272, + "imports": [ + "Std.Data.TreeMap.Basic" + ] + }, + { + "module": "Std.Data.TreeSet.Raw.Basic", + "root": "lean", + "source_path": "src/lean/Std/Data/TreeSet/Raw/Basic.lean", + "source_sha256": "45e8c0454532cf7e7cd0f6a54e2ef404d3236eacad669949456ac920092e6fbd", + "object_path": "lib/lean/Std/Data/TreeSet/Raw/Basic.olean", + "object_sha256": "e3f49a4ef9545ce8ef0d9d8b940ba3375a51d1b34f3890ec6178182805cee208", + "object_bytes": 1411600, + "imports": [ + "Std.Data.TreeMap.Raw.Basic", + "Std.Data.TreeSet.Basic" + ] + }, + { + "module": "Std.Data.TreeSet.AdditionalOperations", + "root": "lean", + "source_path": "src/lean/Std/Data/TreeSet/AdditionalOperations.lean", + "source_sha256": "c724b946add515cbe444da30adf09340c3b706eb5a7f98678296f045e686f1ff", + "object_path": "lib/lean/Std/Data/TreeSet/AdditionalOperations.olean", + "object_sha256": "b9982b9bf47a8111c1f91ea4a79eecac89ef4ade3d42bd243e329836830acfa1", + "object_bytes": 90824, + "imports": [ + "Std.Data.TreeSet.Basic", + "Std.Data.TreeSet.Raw.Basic", + "Std.Data.TreeMap.AdditionalOperations" + ] + }, + { + "module": "Std.Data.TreeSet.Lemmas", + "root": "lean", + "source_path": "src/lean/Std/Data/TreeSet/Lemmas.lean", + "source_sha256": "b857776a34a66ebcdf60f18634be7eaded6e7701be5fa03217a8285c7f81e6be", + "object_path": "lib/lean/Std/Data/TreeSet/Lemmas.olean", + "object_sha256": "ae03b66ab2c72530166332d94f22985877919d0e2d6a6724255833b5d650edaa", + "object_bytes": 716920, + "imports": [ + "Std.Data.TreeMap.Lemmas", + "Std.Data.TreeSet.Basic" + ] + }, + { + "module": "Std.Data.TreeSet", + "root": "lean", + "source_path": "src/lean/Std/Data/TreeSet.lean", + "source_sha256": "7bebde6eb1925f5f2510b5670300af44240a7f7e56c6324fabb690001158e7a1", + "object_path": "lib/lean/Std/Data/TreeSet.olean", + "object_sha256": "d9b8d18b85e366eb869bc155731276e50f3319277335781d952d39b3cad46a6a", + "object_bytes": 18256, + "imports": [ + "Std.Data.TreeSet.Basic", + "Std.Data.TreeSet.AdditionalOperations", + "Std.Data.TreeSet.Lemmas" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.ENodeKey", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/ENodeKey.lean", + "source_sha256": "dad488698ade7a4b11d0cdddc3db88f76bfcdec5347b9608252e8b03f77413af", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/ENodeKey.olean", + "object_sha256": "19e8d2bbc7cf87633467120387b5fd6cae1887c95f7a14da061421be33bfa553", + "object_bytes": 58776, + "imports": [ + "Lean.Expr" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.AlphaShareCommon", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/AlphaShareCommon.lean", + "source_sha256": "758975c96cd8fde5404241f5264d4c52d199611ae8899ca5f2b7e8084a01cb92", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/AlphaShareCommon.olean", + "object_sha256": "e2670ecaca335151db83ffc4146c64e816041768598c29e479d364c4901e9b92", + "object_bytes": 397304, + "imports": [ + "Lean.Meta.Tactic.Grind.ENodeKey" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Arith.Util", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Arith/Util.lean", + "source_sha256": "fa713882b3e2a9aeccc44d399229a1537f473c222bb4b8f6952e52ec1b5ad7be", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Util.olean", + "object_sha256": "b2311635580451d81d10c5b4d6ec7c68367232aa21a00e66a42841dd66bf804a", + "object_bytes": 195200, + "imports": [ + "Lean.Expr", + "Lean.Message" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Arith.Offset.Util", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Util.lean", + "source_sha256": "52a085ae3e7d5160d1634f9ac28d80d42933a4ec29bdd8ed7c85a5d18217b7c9", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Util.olean", + "object_sha256": "15b2d1c01076c86e6bd88c68d0d5dc7add9678e75abe1505c7ea1fb4f781c801", + "object_bytes": 170120, + "imports": [ + "Lean.Expr", + "Lean.Message", + "Lean.Meta.Tactic.Grind.Arith.Util" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Arith.Offset.Types", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Types.lean", + "source_sha256": "3e1208381033503726214ef4b4e337af609c9e40f8bff8accae91d06e8975308", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Types.olean", + "object_sha256": "9e0d8215517e4de17044a6585f9699f9b14397c0d6a9f533ede94a2ac1176fc6", + "object_bytes": 264768, + "imports": [ + "Lean.Data.AssocList", + "Lean.Data.PersistentArray", + "Lean.Meta.Tactic.Grind.ENodeKey", + "Lean.Meta.Tactic.Grind.Arith.Util", + "Lean.Meta.Tactic.Grind.Arith.Offset.Util" + ] + }, + { + "module": "Std.Internal.Rat", + "root": "lean", + "source_path": "src/lean/Std/Internal/Rat.lean", + "source_sha256": "6dbdbecc06891df8d22890dc47eb7e21f8775c2e13644e7082c41274092f2c65", + "object_path": "lib/lean/Std/Internal/Rat.olean", + "object_sha256": "4a0953a613abac91ba5114203dd6761e73e0fad7ae8cd32e1dc262753adf5d1c", + "object_bytes": 225072, + "imports": [ + "Init.NotationExtra", + "Init.Data.ToString.Macro", + "Init.Data.Int.DivMod.Basic", + "Init.Data.Int.Linear", + "Init.Data.Nat.Gcd" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Arith.Cutsat.Types", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Types.lean", + "source_sha256": "e5d5b78e694baccf741846b1c27dddf2aac68edc111585f0a58d1b7bdf73b920", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Types.olean", + "object_sha256": "c9926bbd7a0c38214e2bd93d88b5d2b44290052d4c30a147698e10947cb1aff0", + "object_bytes": 2211584, + "imports": [ + "Init.Data.Int.Linear", + "Std.Internal.Rat", + "Lean.Data.PersistentArray", + "Lean.Meta.Tactic.Grind.ENodeKey", + "Lean.Meta.Tactic.Grind.Arith.Util" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Arith.CommRing.Poly", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/Poly.lean", + "source_sha256": "8e2c038e1c579dc1c03ed6c7fa9be242b775ce3227758e7cea6fe3413c06746f", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/Poly.olean", + "object_sha256": "1a4b236a9cbbc6177ebe1e3e2fb1a22d21c83e336d5453ddf38e15ee3d55d79f", + "object_bytes": 467696, + "imports": [ + "Init.Grind.CommRing.Poly" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Arith.CommRing.Types", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/Types.lean", + "source_sha256": "db4cc9c4c9cc1611bd54a3444edbf8cc139c45333193f0c27773289d26217db7", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/Types.olean", + "object_sha256": "1aff0efd5cdd6fd6ceba555411b40e054629f09c675daf1b2d4ec30f54187d2d", + "object_bytes": 703480, + "imports": [ + "Lean.Data.PersistentArray", + "Lean.Data.RBTree", + "Lean.Meta.Tactic.Grind.ENodeKey", + "Lean.Meta.Tactic.Grind.Arith.Util", + "Lean.Meta.Tactic.Grind.Arith.CommRing.Poly" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Arith.Types", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Arith/Types.lean", + "source_sha256": "1cab99852cc9d633cec81b04f45fe130815ee044da42c92d7da0155b054bd448", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Types.olean", + "object_sha256": "132b7af7654160b808d77c264089f6439b8a843cc2056127fe14ff840d905091", + "object_bytes": 109168, + "imports": [ + "Lean.Meta.Tactic.Grind.Arith.Offset.Types", + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Types", + "Lean.Meta.Tactic.Grind.Arith.CommRing.Types" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Types", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Types.lean", + "source_sha256": "c6b36d1510b379c3664c814aebc648f081f84a91c950a4756ad31e059a00673d", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Types.olean", + "object_sha256": "98940c86093b3b6eab975bf484b4934b34cc3ba3caf80f3aa993fec1a9770341", + "object_bytes": 4622456, + "imports": [ + "Init.Grind.Tactics", + "Init.Data.Queue", + "Std.Data.TreeSet", + "Lean.HeadIndex", + "Lean.Meta.Basic", + "Lean.Meta.CongrTheorems", + "Lean.Meta.AbstractNestedProofs", + "Lean.Meta.Tactic.Simp.Types", + "Lean.Meta.Tactic.Util", + "Lean.Meta.Tactic.Ext", + "Lean.Meta.Tactic.Grind.ENodeKey", + "Lean.Meta.Tactic.Grind.AlphaShareCommon", + "Lean.Meta.Tactic.Grind.Attr", + "Lean.Meta.Tactic.Grind.ExtAttr", + "Lean.Meta.Tactic.Grind.Cases", + "Lean.Meta.Tactic.Grind.Arith.Types", + "Lean.Meta.Tactic.Grind.EMatchTheorem" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Injection", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Injection.lean", + "source_sha256": "d8627ae3e1021e87e6ac39e8651ea843f2d3d2fd8f440c2793ae82b5043d727d", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Injection.olean", + "object_sha256": "327139a081252ee49e127487ce88613434d67bba26139819d17e873187e34b37", + "object_bytes": 132272, + "imports": [ + "Lean.Meta.CtorRecognizer", + "Lean.Meta.Tactic.Util", + "Lean.Meta.Tactic.Clear" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Proof", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Proof.lean", + "source_sha256": "aa86a45d39bc14c9e7255cbaeda2214c1f97608ca080ab070d4b511e742ee539", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Proof.olean", + "object_sha256": "c60d4a83a5082af173aaef4428a936c5a735a4c75c8ef1561e1a1f21a206eaae", + "object_bytes": 1043680, + "imports": [ + "Init.Grind.Lemmas", + "Lean.Meta.Tactic.Grind.Types" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.MatchDiscrOnly", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/MatchDiscrOnly.lean", + "source_sha256": "5b193dc06f4410645ad4416c2068a88f862d3121577c0a0f43f7a2f447c30337", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/MatchDiscrOnly.olean", + "object_sha256": "d83b4ce6efdbd0b00464d44a55ae4996a4a8035919ace8fe7482ffaea2accb8d", + "object_bytes": 363648, + "imports": [ + "Init.Grind.Util", + "Init.Simproc", + "Lean.Meta.Tactic.Simp.Simproc", + "Lean.Meta.Tactic.Simp.Rewrite" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.MarkNestedProofs", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/MarkNestedProofs.lean", + "source_sha256": "733f1a308e1e78a644a56c041fd53975ef0404787bd298b1cc9656ac3d52c828", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/MarkNestedProofs.olean", + "object_sha256": "d43ace1f6310d32ee9d8c0f80da1fca39a04fe65c749e1f077609aac1b4d6ac9", + "object_bytes": 390464, + "imports": [ + "Init.Grind.Util", + "Lean.Util.PtrSet", + "Lean.Meta.Transform", + "Lean.Meta.Basic", + "Lean.Meta.InferType", + "Lean.Meta.Tactic.Grind.Util" + ] + }, + { + "module": "Lean.Util.FVarSubset", + "root": "lean", + "source_path": "src/lean/Lean/Util/FVarSubset.lean", + "source_sha256": "07a656397133b0ebebb75db84457807bf8479b1696aa9ae116dad79b98de545b", + "object_path": "lib/lean/Lean/Util/FVarSubset.olean", + "object_sha256": "9a8d618fd3f1f6ef8d4f0f2ed7c533d5e848a26da2d3440ca8b9b986bccfa0aa", + "object_bytes": 60848, + "imports": [ + "Lean.Util.CollectFVars", + "Lean.Util.FindExpr" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Canon", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Canon.lean", + "source_sha256": "a8cf38513497f1d938b0e0eaf22f42a9dd561c7f34033762b751139cf8be6aa9", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Canon.olean", + "object_sha256": "bfd1375e2e0b8a575a521798070fa8137cd42e9d7217001e91f478e6b9f52afa", + "object_bytes": 1683880, + "imports": [ + "Init.Grind.Util", + "Lean.Meta.Basic", + "Lean.Meta.FunInfo", + "Lean.Util.FVarSubset", + "Lean.Util.PtrSet", + "Lean.Util.FVarSubset", + "Lean.Meta.Tactic.Grind.Types" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Simp", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Simp.lean", + "source_sha256": "ded2b15e843bc70756e87a34058faba5c0a8440d7a7fea9111ba46471f61b32e", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Simp.olean", + "object_sha256": "258def942c871814245bbb7eb1399f7c4b1356200025c80c5f8959f602d15988", + "object_bytes": 365864, + "imports": [ + "Init.Grind.Lemmas", + "Lean.Meta.Tactic.Assert", + "Lean.Meta.Tactic.Simp.Main", + "Lean.Meta.Tactic.Grind.Util", + "Lean.Meta.Tactic.Grind.Types", + "Lean.Meta.Tactic.Grind.MatchDiscrOnly", + "Lean.Meta.Tactic.Grind.MarkNestedProofs", + "Lean.Meta.Tactic.Grind.Canon" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.ProveEq", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/ProveEq.lean", + "source_sha256": "b98fde495ac1c8c59fda5b72cd6f5b08ea1564353a9cda382f5d41cb9d42b752", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/ProveEq.olean", + "object_sha256": "6784f379a02db23349268047ce77f57356426266eb66dfb2a6078dc39df1fed5", + "object_bytes": 791048, + "imports": [ + "Lean.Meta.Tactic.Grind.Types", + "Lean.Meta.Tactic.Grind.Simp" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.PropagatorAttr", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/PropagatorAttr.lean", + "source_sha256": "7157b3ea37e331bcd0c6f5f70d3dd26110be2f6de8491ae91513e988635865f0", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/PropagatorAttr.olean", + "object_sha256": "e5f7f2355641de07e91837301c47adc928fbcad55283ce8b71117ffc1bd817db", + "object_bytes": 415360, + "imports": [ + "Init.Grind", + "Lean.Meta.Tactic.Grind.Proof" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.MatchCond", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/MatchCond.lean", + "source_sha256": "68019c649e7fee61e1f5875646e03434efcf27fbee06d6be7888b96e992deab4", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/MatchCond.olean", + "object_sha256": "adef35f1bcfab782e64834b0ee85f0416f19d0fa6e9c0cc25327c76e947d4657", + "object_bytes": 1429432, + "imports": [ + "Init.Grind", + "Init.Simproc", + "Lean.Meta.Tactic.Contradiction", + "Lean.Meta.Tactic.Grind.ProveEq", + "Lean.Meta.Tactic.Grind.PropagatorAttr" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Arith.Offset.Proof", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Proof.lean", + "source_sha256": "779a8118968dffe0c1a3902d20618bcd8cf482a7ddb6144ab2f4afe44652c3a2", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Proof.olean", + "object_sha256": "cb8f8b6eade9d8b4d6a7d9ddfe6cadecc7f3f8bc9d302b536508e48d276429b9", + "object_bytes": 268888, + "imports": [ + "Init.Grind.Offset", + "Init.Grind.Lemmas", + "Lean.Meta.Tactic.Grind.Types" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Arith.Offset.Main", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Main.lean", + "source_sha256": "35dd71295a33ddbfb6edfb712c92bdfa140c9b61cd260cc883c3cd008d355b76", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Main.olean", + "object_sha256": "4b371cf366c95aeb4dad07c40def0cb4cdd3ab35ed6a4ea459ea951cd0fce052", + "object_bytes": 1553904, + "imports": [ + "Init.Grind.Offset", + "Lean.Meta.Tactic.Grind.Types", + "Lean.Meta.Tactic.Grind.Arith.Offset.Proof", + "Lean.Meta.Tactic.Grind.Arith.Offset.Util" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Arith.Offset", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Arith/Offset.lean", + "source_sha256": "84ac965a81ea4267ee17f597a40efa6757511dc9f46430d572b48daff982dea6", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset.olean", + "object_sha256": "a0bc8e5e3b0c015f6bf988b82cd20378c49105774213aacd67ba54e4fb3e69e3", + "object_bytes": 83272, + "imports": [ + "Lean.Meta.Tactic.Grind.Arith.Offset.Main", + "Lean.Meta.Tactic.Grind.Arith.Offset.Proof", + "Lean.Meta.Tactic.Grind.Arith.Offset.Util", + "Lean.Meta.Tactic.Grind.Arith.Offset.Types" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Arith.Cutsat.Util", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Util.lean", + "source_sha256": "ab5cd10f39f2d0d0b41fc4fc3b7647f5c2772a9d14947cbf67f7679424b6c5fc", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Util.olean", + "object_sha256": "7490e606456d0c6d3bdc54282f5909ecf3bb2fd027d2bc2881ef0868915cb738", + "object_bytes": 793336, + "imports": [ + "Lean.Meta.Tactic.Grind.Types" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Arith.Cutsat.Foreign", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Foreign.lean", + "source_sha256": "21763680a6be747c1c99d8b81f260ee1eee0b8dac396909b87d6ccceaaa233ce", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Foreign.olean", + "object_sha256": "11ed63e7a32c6fa51789e876a044051255067b98e85a0c5659376044c328551a", + "object_bytes": 308240, + "imports": [ + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Util" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Arith.Cutsat.Norm", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Norm.lean", + "source_sha256": "86342432058a3f7a6a59a8b2dde561e8b845edaeedd546c995fb7e37720c8330", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Norm.olean", + "object_sha256": "37c20f1f1aede6438aec245835bdce5195f5ec787581492871faadb8e75ebe3b", + "object_bytes": 210536, + "imports": [ + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Util" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Arith.Cutsat.Nat", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Nat.lean", + "source_sha256": "8c3ee6ea04272fe57d3a74f0fb6add7b97807654b694f440fdd360ac707cca1f", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Nat.olean", + "object_sha256": "cedbd633e9e9b8f44ef59b2b1168e63224792d7947291a840673d21e1b293fde", + "object_bytes": 552776, + "imports": [ + "Init.Data.Int.OfNat", + "Lean.Meta.Tactic.Grind.Simp", + "Lean.Meta.Tactic.Simp.Arith.Nat.Basic", + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Foreign", + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Norm" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Arith.Cutsat.Var", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Var.lean", + "source_sha256": "069ed670448cdee109edbb6e0072a379794d7f9edc10d99c6f03c541faa2bc85", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Var.olean", + "object_sha256": "606950743d617161aa309803684a046e682288cbc7b2a945eb6e1cd0af43ed00", + "object_bytes": 436016, + "imports": [ + "Lean.Meta.IntInstTesters", + "Lean.Meta.Tactic.Grind.Simp", + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Util", + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Nat" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Arith.Cutsat.Inv", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Inv.lean", + "source_sha256": "787288d4bc4793ca8412b9f80e1d666e55fe4f3045b884775fa17e946a168530", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Inv.olean", + "object_sha256": "c0fbd44470e46d817aa87c0b89a99c895369a740c1d39b4897b05c275110e456", + "object_bytes": 744544, + "imports": [ + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Util", + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Var" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Arith.Inv", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Arith/Inv.lean", + "source_sha256": "b7492d1246b2d91e084d5440f20530e5639ecfe4fc3dbb8bacf02c4f6bf68941", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Inv.olean", + "object_sha256": "b7c546d1134d178220f557ff319c4a4c82ae4798638c60019a55562edd881fa5", + "object_bytes": 31896, + "imports": [ + "Lean.Meta.Tactic.Grind.Arith.Offset", + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Inv" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Inv", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Inv.lean", + "source_sha256": "6b04a2c606fdc316b229066e69b27961f3504eb64c2c5fcf5e39b7fc3f6e9bc7", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Inv.olean", + "object_sha256": "5c1c9586d0fd6380b4539f556cbe755843acd15634a6224364ccaf2b3beab634", + "object_bytes": 797168, + "imports": [ + "Lean.Meta.Tactic.Grind.Types", + "Lean.Meta.Tactic.Grind.Proof", + "Lean.Meta.Tactic.Grind.MatchCond", + "Lean.Meta.Tactic.Grind.Arith.Inv" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Arith.Offset.Model", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Model.lean", + "source_sha256": "44e9366515ea3af48a0489c626a318e80f3dafd00ed8410b0af34bbca595c7ff", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Model.olean", + "object_sha256": "8670edb120416d8ef1f26c7921a30a663beca9c89f261e9e10f449390ac3bf0d", + "object_bytes": 367224, + "imports": [ + "Lean.Meta.Basic", + "Lean.Meta.Tactic.Grind.Types", + "Lean.Meta.Tactic.Grind.Util" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Arith.Cutsat.Model", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Model.lean", + "source_sha256": "00da0fc9b0a71a591bc37cf3c772016992ced67dda8f783ebd205241d7a095cd", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Model.olean", + "object_sha256": "d9c177cbbfc94c28ffb512e9c4e095fd7c5ecf7e8c2d04e637e11f826e204ee4", + "object_bytes": 846576, + "imports": [ + "Lean.Meta.Tactic.Grind.Types" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Arith.Model", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Arith/Model.lean", + "source_sha256": "bfbd32334948f3a2d88bc07aa03ea122ea6974bcb86f16084c699ff8729a1f35", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Model.olean", + "object_sha256": "f6c14f80da0602ef55590eb3109b06d12cd215e63c8d4669a6009d0462fdb9f0", + "object_bytes": 18160, + "imports": [ + "Lean.Meta.Tactic.Grind.Arith.Offset.Model", + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Model" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Arith.CommRing.Util", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/Util.lean", + "source_sha256": "dc365baf06192eef3869621edd628c465e2c2256f8fc7406d0d659ea6a3c3a19", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/Util.olean", + "object_sha256": "763b8f046ae3e5cd2b1b6f992b8910d99f569e50fc95132d444bcde7c5188e72", + "object_bytes": 590360, + "imports": [ + "Lean.Meta.Tactic.Grind.Types", + "Lean.Meta.Tactic.Grind.Arith.CommRing.Poly" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Arith.CommRing.Var", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/Var.lean", + "source_sha256": "c46895114bb40ee7211da0a8dabab58a90c41579c92b5b3ea40c6c9f1ae09a8b", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/Var.olean", + "object_sha256": "9b2f3844fff92f536745173d246af04da452ee87e9f0716c76d044a2bab54a0c", + "object_bytes": 196336, + "imports": [ + "Lean.Meta.Tactic.Grind.Arith.CommRing.Util" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Arith.CommRing.DenoteExpr", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/DenoteExpr.lean", + "source_sha256": "7317aebd2bc1d4337bd8a2e25adc95e89b4f051124494ec39e70b2238aa9612d", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/DenoteExpr.olean", + "object_sha256": "64517167645786c65d2dfae6fc50ef3ce3de8ad6f1496f674d80c4864911a0fc", + "object_bytes": 243352, + "imports": [ + "Lean.Meta.Tactic.Grind.Arith.CommRing.Util", + "Lean.Meta.Tactic.Grind.Arith.CommRing.Var" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Arith.CommRing.PP", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/PP.lean", + "source_sha256": "be24b7d2d64ad68c10b6c7d915a51dde6832ca07e05a6f270126e06b0357673f", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/PP.olean", + "object_sha256": "996e3729264d22ce943f657868a4b1e0245e3400b12d7968b5ce525674ee120b", + "object_bytes": 303896, + "imports": [ + "Lean.Meta.Tactic.Grind.Arith.CommRing.DenoteExpr" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.PP", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/PP.lean", + "source_sha256": "830774f149a52c6f7b2db1ffcbc8fa3eda60e49f9e48c7e591da5549f7dbdcf6", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/PP.olean", + "object_sha256": "a62dc76d15b1bea2e5261b85f3c2fdfbb454b03ea4db0110c72601a3c4d8061d", + "object_bytes": 870112, + "imports": [ + "Init.Grind.Util", + "Init.Grind.PP", + "Lean.Meta.Tactic.Grind.Types", + "Lean.Meta.Tactic.Grind.Arith.Model", + "Lean.Meta.Tactic.Grind.Arith.CommRing.PP" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Ctor", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Ctor.lean", + "source_sha256": "d2373b820675e537590ee0365c467dd852e7885a05de209e097f08d1c020f81a", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Ctor.olean", + "object_sha256": "afa43a96b9cdab57736b219d8660c390e6ed7f2a98664e99ca1925bab200224c", + "object_bytes": 270592, + "imports": [ + "Lean.Meta.Tactic.Grind.Types" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Beta", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Beta.lean", + "source_sha256": "69395997470b191c4c182bb6db814d45915f8a34d5c611bfa1491c30dafadae2", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Beta.olean", + "object_sha256": "8dbcfed17446ceda6ab3fa0233c8aa997db429b27b0bd9f6145a84cb96b062eb", + "object_bytes": 426992, + "imports": [ + "Lean.Meta.Tactic.Grind.Types" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Diseq", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Diseq.lean", + "source_sha256": "05791d0d14af85ffe10ee7d9c3c9caecbd7b5db61103e2ab415efc33556ed82b", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Diseq.olean", + "object_sha256": "1b2f4f9e308d61d24372e63dd6e293be8d2e3dde65fd490f040fb4592a98f533", + "object_bytes": 308208, + "imports": [ + "Init.Grind.Lemmas", + "Lean.Meta.Tactic.Grind.Types" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Arith.ProofUtil", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Arith/ProofUtil.lean", + "source_sha256": "192ecde21e723bce88f265d60a281345f435aa792965a3325b3d573ff2933200", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/ProofUtil.olean", + "object_sha256": "2b031068d5be34e144b73ee29ea898c819cc97098413c6cad73358df5ea83bee", + "object_bytes": 113432, + "imports": [ + "Lean.Meta.Tactic.Grind.Types" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Proof.lean", + "source_sha256": "a48fd7fd52aefe2137a09601a3e2629b7a40f59cca528c2958ec54763833a4a8", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Proof.olean", + "object_sha256": "a7958494cb0e1d7543499b9b192cda7aa25c2087e05582bcb0c038fdef05703b", + "object_bytes": 2890752, + "imports": [ + "Lean.Meta.Tactic.Grind.Diseq", + "Lean.Meta.Tactic.Grind.Arith.ProofUtil", + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Util", + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Nat" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Arith.Cutsat.DvdCnstr", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/DvdCnstr.lean", + "source_sha256": "a0c2c040bd66acbd11d7a36a0ac0582bb329e497e7039576c1223a092b9ac4e7", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/DvdCnstr.olean", + "object_sha256": "5d0c1f3e3bf08a628d4b909739f5a2080b16d48c32c7b52ed5d8282c8c634c83", + "object_bytes": 618624, + "imports": [ + "Lean.Meta.Tactic.Simp.Arith.Int", + "Lean.Meta.Tactic.Grind.PropagatorAttr", + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Var", + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Util", + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof", + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Norm" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Arith.Cutsat.LeCnstr", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/LeCnstr.lean", + "source_sha256": "bf5ef514dbcf48b9ec7607c54c713d00d541b01c9df7daed14ea9d2157637fc0", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/LeCnstr.olean", + "object_sha256": "58b6a760b49d763d1cfc73f7edf31fa54deedd4cc9c651058e4f3499cb63c31f", + "object_bytes": 1244256, + "imports": [ + "Lean.Meta.Tactic.Simp.Arith.Int", + "Lean.Meta.Tactic.Grind.PropagatorAttr", + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Var", + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Util", + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof", + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Nat", + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Norm" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/EqCnstr.lean", + "source_sha256": "3ffd428fd30e957058ee03cc91bee27435b7b94526356ca06a1760b6d77226cd", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/EqCnstr.olean", + "object_sha256": "d4122c5037d63ccbd13aff9b007cf3e61a4f600d6e7f52f9c7d4fc22e4fbcb6b", + "object_bytes": 2186912, + "imports": [ + "Lean.Meta.Tactic.Grind.Simp", + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Var", + "Lean.Meta.Tactic.Grind.Arith.Cutsat.DvdCnstr", + "Lean.Meta.Tactic.Grind.Arith.Cutsat.LeCnstr" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Arith.CommRing.RingId", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/RingId.lean", + "source_sha256": "da858bc010f4253f6bc9678e994aa2789d8805fe096b9e15f9ebefd129a1d54d", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/RingId.olean", + "object_sha256": "cc4a0664301eb0e49415701b0dd669c4e749f2fb88870c1ff25ca7ed45c28dd1", + "object_bytes": 807160, + "imports": [ + "Lean.Meta.Tactic.Grind.Simp", + "Lean.Meta.Tactic.Grind.Arith.CommRing.Util" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Arith.CommRing.Reify", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/Reify.lean", + "source_sha256": "c64281650727e9e07a9da1f126ce8939ec2d949446078dd02c9ef25f069650cf", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/Reify.olean", + "object_sha256": "8e74f95ed77f0135a97eea108983b02bc6a9967e229a06ab3417f11a3e830927", + "object_bytes": 379656, + "imports": [ + "Lean.Meta.Tactic.Grind.Simp", + "Lean.Meta.Tactic.Grind.Arith.CommRing.Util", + "Lean.Meta.Tactic.Grind.Arith.CommRing.Var" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Arith.CommRing.Internalize", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/Internalize.lean", + "source_sha256": "f6e917c28bb379327da7b745acbf762392b720536da651e259d74b3eeed2315d", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/Internalize.olean", + "object_sha256": "6c528e5a505bff505e1ab31a4e66d4282e8d4fde92c0b22968e01cb93bb84bd4", + "object_bytes": 345232, + "imports": [ + "Lean.Meta.Tactic.Grind.Simp", + "Lean.Meta.Tactic.Grind.Arith.CommRing.RingId", + "Lean.Meta.Tactic.Grind.Arith.CommRing.Reify" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Arith.Internalize", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Arith/Internalize.lean", + "source_sha256": "f2e02c87e6520bd73b32cc732bacec4e9ac4ca4e583da30afaa57c55c0ec059c", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Internalize.olean", + "object_sha256": "779146c07f8653d14dc4a6a2c3d7dca422c3b2d59e6ae69986926d7490085e00", + "object_bytes": 37240, + "imports": [ + "Lean.Meta.Tactic.Grind.Arith.Offset", + "Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr", + "Lean.Meta.Tactic.Grind.Arith.CommRing.Internalize" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Internalize", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Internalize.lean", + "source_sha256": "a42dcb0d8f9e960b8bb69b63b5990e59c01e3376ecf6be82768b3a3ffab2151e", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Internalize.olean", + "object_sha256": "312a4665bd03a1de39ae58c5eb3cdf9f6439dba04ffb518f7db0fd62d8106eb4", + "object_bytes": 2540664, + "imports": [ + "Init.Grind.Util", + "Init.Grind.Lemmas", + "Lean.Meta.LitValues", + "Lean.Meta.Match.MatcherInfo", + "Lean.Meta.Match.MatchEqsExt", + "Lean.Meta.Match.MatchEqs", + "Lean.Meta.Tactic.Grind.Types", + "Lean.Meta.Tactic.Grind.Util", + "Lean.Meta.Tactic.Grind.Canon", + "Lean.Meta.Tactic.Grind.Beta", + "Lean.Meta.Tactic.Grind.MatchCond", + "Lean.Meta.Tactic.Grind.Arith.Internalize" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Core", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Core.lean", + "source_sha256": "fe446e6e638e4669d0836ba985591955d0a9b798572c4cacec3d57c4cd7fa0e9", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Core.olean", + "object_sha256": "e9fdcfba1df8f75849709f2ba9352911cc8223e1a315a8ffd95a1620fefda9e0", + "object_bytes": 1529912, + "imports": [ + "Init.Grind.Util", + "Lean.Meta.LitValues", + "Lean.Meta.Tactic.Grind.Types", + "Lean.Meta.Tactic.Grind.Inv", + "Lean.Meta.Tactic.Grind.PP", + "Lean.Meta.Tactic.Grind.Ctor", + "Lean.Meta.Tactic.Grind.Util", + "Lean.Meta.Tactic.Grind.Beta", + "Lean.Meta.Tactic.Grind.Internalize", + "Lean.Meta.Tactic.Grind.Simp" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Ext", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Ext.lean", + "source_sha256": "2fe0b423028d73d1b2ab3a023e5aa37103752b8af2ab479334671d7970f32418", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Ext.olean", + "object_sha256": "812976a53d01304844887ecc139511c70f2f7c33ccd25505a4f20fec48e12997", + "object_bytes": 400728, + "imports": [ + "Lean.Meta.Tactic.Grind.Types" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Propagate", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Propagate.lean", + "source_sha256": "92eed9cae6d63c41cbb5f06fe7e27a67044e3b351c67f610561b373b811d3312", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Propagate.olean", + "object_sha256": "932eda43a7259315eeb59505596af74851e1d25a36b11077c07700190e924d15", + "object_bytes": 1184200, + "imports": [ + "Init.Grind", + "Lean.Meta.Tactic.Grind.Proof", + "Lean.Meta.Tactic.Grind.PropagatorAttr", + "Lean.Meta.Tactic.Grind.Simp", + "Lean.Meta.Tactic.Grind.Ext", + "Lean.Meta.Tactic.Grind.Internalize" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Parser", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Parser.lean", + "source_sha256": "440f710ccff348609dbc32853c737639c842b08dbcd5726db1b6b77f55eda57f", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Parser.olean", + "object_sha256": "becc215081420e2cf92c9e35d38f90139607b39825ac62b7b7f1d6b2cba83a56", + "object_bytes": 108448, + "imports": [ + "Lean.Parser.Command" + ] + }, + { + "module": "Lean.Meta.Match.MatcherApp", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Match/MatcherApp.lean", + "source_sha256": "71ebbbc20b3eeaf92f26a049861b2922f73681a9083a3a178c6ecadf6aefc879", + "object_path": "lib/lean/Lean/Meta/Match/MatcherApp.olean", + "object_sha256": "2933340ac93e246a3a056bd2d020226e0aef7e772fd1fe236e392dcb601ca270", + "object_bytes": 18008, + "imports": [ + "Lean.Meta.Match.MatcherApp.Basic", + "Lean.Meta.Match.MatcherApp.Transform" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.CasesMatch", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/CasesMatch.lean", + "source_sha256": "ba60160f55f4e950cb0ceb310050d810e1bae372f772b88e5302858e9b412025", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/CasesMatch.olean", + "object_sha256": "6f4466d505b76cd31a08b11bede7748412083bf5540fc9df52535ed5e6907f14", + "object_bytes": 238040, + "imports": [ + "Lean.Meta.Tactic.Util", + "Lean.Meta.Tactic.Cases", + "Lean.Meta.Match.MatcherApp", + "Lean.Meta.Tactic.Grind.MatchCond" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.SearchM", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/SearchM.lean", + "source_sha256": "311d0e8ace41ff4eb5371baf529e82cf87a9370b271fb333638cea58bcb84ea3", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/SearchM.olean", + "object_sha256": "0060014d505dd2e048c327579d6062551978ea674f91e98355fb7fe82f57050a", + "object_bytes": 1385512, + "imports": [ + "Lean.Util.ForEachExpr", + "Lean.Meta.Tactic.Grind.Types" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Intro", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Intro.lean", + "source_sha256": "382c899d651718f2f6587080755565fdc1b0ecad1d1bfd1bfb8b6a1c5a3ccd0b", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Intro.olean", + "object_sha256": "55ca73276cca54eeb84472790bb77a76a7faa8225ba30299f5446fc87740788d", + "object_bytes": 1605672, + "imports": [ + "Init.Grind.Lemmas", + "Lean.Meta.Tactic.Assert", + "Lean.Meta.Tactic.Grind.Simp", + "Lean.Meta.Tactic.Grind.Types", + "Lean.Meta.Tactic.Grind.Cases", + "Lean.Meta.Tactic.Grind.CasesMatch", + "Lean.Meta.Tactic.Grind.Injection", + "Lean.Meta.Tactic.Grind.Core", + "Lean.Meta.Tactic.Grind.SearchM" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.EMatch", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/EMatch.lean", + "source_sha256": "74402f87bdd924d3d4e1869fc4152a375c5653b8e0398c744759cf5eab1d54d8", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/EMatch.olean", + "object_sha256": "3724573a112d896ad1ecd056d8c3b527501f6f4b99546c29a10fe9ef845ca5fe", + "object_bytes": 2602208, + "imports": [ + "Lean.Meta.Tactic.Grind.Types", + "Lean.Meta.Tactic.Grind.Intro", + "Lean.Meta.Tactic.Grind.MatchDiscrOnly", + "Lean.Meta.Tactic.Grind.MatchCond", + "Lean.Meta.Tactic.Grind.Core" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Proj", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Proj.lean", + "source_sha256": "687e81c47368e7f71ff53b3f5ffe84c2b38b7020446dbda5603505f62380c9d5", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Proj.olean", + "object_sha256": "39f909e14cc12f398435fef0ee80f638dce07ae7ce44d9aeb1c8af82d39de79b", + "object_bytes": 176624, + "imports": [ + "Lean.ProjFns", + "Lean.Meta.Tactic.Grind.Types", + "Lean.Meta.Tactic.Grind.Internalize" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.EqResolution", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/EqResolution.lean", + "source_sha256": "69294ea2ac315c6fa3a143f1e3f45a444523e70bfb5d7729382b44b9cbcd9af8", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/EqResolution.olean", + "object_sha256": "964b07c1c3b79590f6fa06b8727820c165d3384b354f43c0eb0fc5ce7df9848b", + "object_bytes": 266584, + "imports": [ + "Lean.Meta.AppBuilder", + "Lean.Meta.MatchUtil" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.ForallProp", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/ForallProp.lean", + "source_sha256": "1c8869dbab792debda96fa3a8cfe94e10ac9b11814e89e57ff4d08ea5ed14e3c", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/ForallProp.olean", + "object_sha256": "3d0829012786444ef7d2ac0400dd374e54da38897602c565e719cb7157bb07e9", + "object_bytes": 581336, + "imports": [ + "Init.Grind.Lemmas", + "Lean.Meta.Tactic.Grind.Types", + "Lean.Meta.Tactic.Grind.Internalize", + "Lean.Meta.Tactic.Grind.Simp", + "Lean.Meta.Tactic.Grind.EqResolution" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Split", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Split.lean", + "source_sha256": "242d2c9033c3885ce8411c6e301e0a7f6684f6bafe1299f403715fd899f3615f", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Split.olean", + "object_sha256": "c93171d056840671308bd45b6f6cc99c525c183d43c6e206bafeeef04590c487", + "object_bytes": 1506688, + "imports": [ + "Lean.Meta.Tactic.Grind.Types", + "Lean.Meta.Tactic.Grind.Intro", + "Lean.Meta.Tactic.Grind.Cases", + "Lean.Meta.Tactic.Grind.CasesMatch", + "Lean.Meta.Tactic.Grind.SearchM" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Arith.Cutsat.SearchM", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/SearchM.lean", + "source_sha256": "2eb83a67b4887da3d843c08155f361b781f0b882e5f7c2c9b5f135a4806ccbd9", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/SearchM.olean", + "object_sha256": "764364fecea654c6e463a9d3f41de66950289c04ad66bddbc763d606a89a2841", + "object_bytes": 306856, + "imports": [ + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Util" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Arith.Cutsat.Search", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Search.lean", + "source_sha256": "c8351d14e152a50a98c8d214841b89fea289db4afb4bd466a6ee36af513860cd", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Search.olean", + "object_sha256": "27aa6eb89cdee3ce2cba287a80fd54d11a08b4e2c8f5fb2b6374bd8bd0f95f23", + "object_bytes": 2498368, + "imports": [ + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Var", + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Util", + "Lean.Meta.Tactic.Grind.Arith.Cutsat.DvdCnstr", + "Lean.Meta.Tactic.Grind.Arith.Cutsat.LeCnstr", + "Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr", + "Lean.Meta.Tactic.Grind.Arith.Cutsat.SearchM", + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Model" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Arith.CommRing.ToExpr", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/ToExpr.lean", + "source_sha256": "2ca96739962278746171237fbc3791a59c501287ae30434e66e40d82f91ce3b9", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/ToExpr.olean", + "object_sha256": "8a3e5bf78a8181cdf9a6d201243804d532c30e819bcf0c7be8a2ac7b99b518ad", + "object_bytes": 159744, + "imports": [ + "Init.Grind.CommRing.Poly", + "Lean.ToExpr" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Arith.CommRing.Proof", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/Proof.lean", + "source_sha256": "cec97aac7ce9565d2eae881ae197fbd5e16b7edb1188fa26b9a698b12224fb54", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/Proof.olean", + "object_sha256": "04f246218626e64317308b66acedc5d33366f1fd6b6f981ac5a590d8493743d0", + "object_bytes": 2631112, + "imports": [ + "Lean.Meta.Tactic.Grind.Diseq", + "Lean.Meta.Tactic.Grind.Arith.ProofUtil", + "Lean.Meta.Tactic.Grind.Arith.CommRing.RingId", + "Lean.Meta.Tactic.Grind.Arith.CommRing.DenoteExpr", + "Lean.Meta.Tactic.Grind.Arith.CommRing.ToExpr" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Arith.CommRing.Inv", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/Inv.lean", + "source_sha256": "3e287739331ee5354cb1a4694bf0b6c62e4a121b6351da58883e2adf68ce9275", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/Inv.olean", + "object_sha256": "6e30ec6deb44a9c40de786edb41298a70a50a6aefa3441e1109fe79536e58f26", + "object_bytes": 442032, + "imports": [ + "Lean.Meta.Tactic.Grind.Arith.CommRing.Util", + "Lean.Meta.Tactic.Grind.Arith.CommRing.Poly" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Arith.CommRing.EqCnstr", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/EqCnstr.lean", + "source_sha256": "60f1b5f0523824e9af36b0f2855e489e0a41d06475b415a64219f9c4daf3f0d3", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/EqCnstr.olean", + "object_sha256": "4cb1a6ba256a06e6b56c89da9177f53e737905a174f4bb84f9aaf932e7d04dda", + "object_bytes": 2395576, + "imports": [ + "Lean.Meta.Tactic.Grind.Arith.CommRing.RingId", + "Lean.Meta.Tactic.Grind.Arith.CommRing.Proof", + "Lean.Meta.Tactic.Grind.Arith.CommRing.DenoteExpr", + "Lean.Meta.Tactic.Grind.Arith.CommRing.Inv" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Arith.Main", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Arith/Main.lean", + "source_sha256": "b67bd4edefb6d67332548fd6228e1c176cc9596d12dfc1e7ce8a8f02a013ceaf", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Main.olean", + "object_sha256": "65367713b3c5106fd8e4c13b059ec88f005990c6cc9ce10c4cc3a97920c34a5e", + "object_bytes": 158560, + "imports": [ + "Lean.Meta.Tactic.Grind.PropagatorAttr", + "Lean.Meta.Tactic.Grind.Arith.Offset", + "Lean.Meta.Tactic.Grind.Arith.Cutsat.LeCnstr", + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Search", + "Lean.Meta.Tactic.Grind.Arith.CommRing.EqCnstr" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.MBTC", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/MBTC.lean", + "source_sha256": "266ef267a162bf6bd62c0369a472dc11074ed791046847ce860765929592d2d2", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/MBTC.olean", + "object_sha256": "9d68b15bec326c31d815f434788ce311d5c9e29bf48167ff1940aaa2ee854bb5", + "object_bytes": 729416, + "imports": [ + "Lean.Meta.Tactic.Grind.Types", + "Lean.Meta.Tactic.Grind.Canon" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Arith.Cutsat.MBTC", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/MBTC.lean", + "source_sha256": "f42754994a0cd07a6c0312d1499b8ae2ea8b17520690f1f7de77370736f571b8", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/MBTC.olean", + "object_sha256": "112c5eaef06b1fdaecec86b1af46c4b2ef1f9075b274dc02f5edff1e397244fa", + "object_bytes": 185032, + "imports": [ + "Lean.Meta.Tactic.Grind.Canon", + "Lean.Meta.Tactic.Grind.MBTC", + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Model" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Arith.Cutsat", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat.lean", + "source_sha256": "42a6015665bf272ae0ee6207d04ec625d075acf35f9a210fad09904d92aeacc4", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat.olean", + "object_sha256": "421ca0eb3187a81af7a575b4e4acd2242bc87907cf4760d6685d85c878dfe768", + "object_bytes": 93840, + "imports": [ + "Lean.Util.Trace", + "Lean.Meta.Tactic.Grind.Arith.Cutsat.DvdCnstr", + "Lean.Meta.Tactic.Grind.Arith.Cutsat.LeCnstr", + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Search", + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Inv", + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof", + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Types", + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Util", + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Var", + "Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr", + "Lean.Meta.Tactic.Grind.Arith.Cutsat.SearchM", + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Model", + "Lean.Meta.Tactic.Grind.Arith.Cutsat.MBTC" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Arith.CommRing", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Arith/CommRing.lean", + "source_sha256": "ae0958a2993239464f43e21547bc7154c5eb4e506dc7a5f524f8106ea1994716", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing.olean", + "object_sha256": "1b831e589760a1af0ce773be96cd3963cd621ef608c4f6c11b236ef95f609ccf", + "object_bytes": 108888, + "imports": [ + "Lean.Util.Trace", + "Lean.Meta.Tactic.Grind.Arith.CommRing.Poly", + "Lean.Meta.Tactic.Grind.Arith.CommRing.Types", + "Lean.Meta.Tactic.Grind.Arith.CommRing.RingId", + "Lean.Meta.Tactic.Grind.Arith.CommRing.Internalize", + "Lean.Meta.Tactic.Grind.Arith.CommRing.ToExpr", + "Lean.Meta.Tactic.Grind.Arith.CommRing.Var", + "Lean.Meta.Tactic.Grind.Arith.CommRing.Reify", + "Lean.Meta.Tactic.Grind.Arith.CommRing.EqCnstr", + "Lean.Meta.Tactic.Grind.Arith.CommRing.Proof", + "Lean.Meta.Tactic.Grind.Arith.CommRing.DenoteExpr", + "Lean.Meta.Tactic.Grind.Arith.CommRing.Inv", + "Lean.Meta.Tactic.Grind.Arith.CommRing.PP" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Arith", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Arith.lean", + "source_sha256": "be324b509038afee7e611f653c47cde93c6fea01893f628b02caba720757e6c8", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith.olean", + "object_sha256": "adb3ac6b6b861714daab44ef434059e0528f724566ba752c1e8aa797d824523b", + "object_bytes": 18592, + "imports": [ + "Lean.Meta.Tactic.Grind.Arith.Util", + "Lean.Meta.Tactic.Grind.Arith.ProofUtil", + "Lean.Meta.Tactic.Grind.Arith.Types", + "Lean.Meta.Tactic.Grind.Arith.Main", + "Lean.Meta.Tactic.Grind.Arith.Offset", + "Lean.Meta.Tactic.Grind.Arith.Cutsat", + "Lean.Meta.Tactic.Grind.Arith.CommRing" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Lookahead", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Lookahead.lean", + "source_sha256": "4221330c4a90574774ae946ba5fb841fa1c25a89d0ff7a23da65e9ae7e917535", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Lookahead.olean", + "object_sha256": "1474a4cc06053a71531c3d53145c69ae7f97ccd78d3ef1ad768602f105a06585", + "object_bytes": 514928, + "imports": [ + "Lean.Meta.Tactic.Grind.Types", + "Lean.Meta.Tactic.Grind.Intro", + "Lean.Meta.Tactic.Grind.Arith", + "Lean.Meta.Tactic.Grind.Split", + "Lean.Meta.Tactic.Grind.EMatch", + "Lean.Meta.Tactic.Grind.SearchM" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Solve", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Solve.lean", + "source_sha256": "2e80ba5a6bd346cafb876e2e9437dd5301e48109b5576df8af38361ea45fa7ab", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Solve.olean", + "object_sha256": "17b45bd99f7a38cf103e15d523480441410eede181b0f1bd1ddf31e7f3d54155", + "object_bytes": 398344, + "imports": [ + "Lean.Meta.Tactic.Grind.Split", + "Lean.Meta.Tactic.Grind.EMatch", + "Lean.Meta.Tactic.Grind.Arith", + "Lean.Meta.Tactic.Grind.Lookahead", + "Lean.Meta.Tactic.Grind.SearchM" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.SimpUtil", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/SimpUtil.lean", + "source_sha256": "43f4253bb306f933dc9dec2d717d1cfe0f8d0c732b88bbe13955f0ebfa6b4f60", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/SimpUtil.olean", + "object_sha256": "5b6f8ad10edd77e7eb4ac6ec740ebb9cb255dac54955942bbd80ce032a51b60b", + "object_bytes": 295232, + "imports": [ + "Lean.Meta.Tactic.Simp.Simproc", + "Lean.Meta.Tactic.Grind.Simp", + "Lean.Meta.Tactic.Grind.MatchDiscrOnly", + "Lean.Meta.Tactic.Grind.MatchCond", + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.List" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind.Main", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind/Main.lean", + "source_sha256": "fffdd0f2286a55d3d055e5b054cd771068a471feae954f2a4156ad5a65f0378b", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind/Main.olean", + "object_sha256": "21511734cd69663d028f31868075ac3edafbfcde2c94a5da37da50636819ab6d", + "object_bytes": 1055112, + "imports": [ + "Init.Grind.Lemmas", + "Lean.Meta.Tactic.Util", + "Lean.Meta.Tactic.ExposeNames", + "Lean.Meta.Tactic.Simp.Diagnostics", + "Lean.Meta.Tactic.Grind.RevertAll", + "Lean.Meta.Tactic.Grind.PropagatorAttr", + "Lean.Meta.Tactic.Grind.Proj", + "Lean.Meta.Tactic.Grind.ForallProp", + "Lean.Meta.Tactic.Grind.Util", + "Lean.Meta.Tactic.Grind.Inv", + "Lean.Meta.Tactic.Grind.Intro", + "Lean.Meta.Tactic.Grind.EMatch", + "Lean.Meta.Tactic.Grind.Split", + "Lean.Meta.Tactic.Grind.Solve", + "Lean.Meta.Tactic.Grind.SimpUtil", + "Lean.Meta.Tactic.Grind.Cases" + ] + }, + { + "module": "Lean.Meta.Tactic.Grind", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Grind.lean", + "source_sha256": "7cbea181e83b87ed16915aafb4949dfbb044a3ab0806a4ef1d1a873af4500769", + "object_path": "lib/lean/Lean/Meta/Tactic/Grind.olean", + "object_sha256": "fb71753f04fedb48a6512ce25e9fafdd67fc8b77e304dcbe2cc2cb981fed3a7b", + "object_bytes": 213232, + "imports": [ + "Lean.Meta.Tactic.Grind.Attr", + "Lean.Meta.Tactic.Grind.RevertAll", + "Lean.Meta.Tactic.Grind.Types", + "Lean.Meta.Tactic.Grind.Util", + "Lean.Meta.Tactic.Grind.Cases", + "Lean.Meta.Tactic.Grind.Injection", + "Lean.Meta.Tactic.Grind.Core", + "Lean.Meta.Tactic.Grind.Canon", + "Lean.Meta.Tactic.Grind.MarkNestedProofs", + "Lean.Meta.Tactic.Grind.Inv", + "Lean.Meta.Tactic.Grind.Proof", + "Lean.Meta.Tactic.Grind.Propagate", + "Lean.Meta.Tactic.Grind.PP", + "Lean.Meta.Tactic.Grind.Simp", + "Lean.Meta.Tactic.Grind.Ctor", + "Lean.Meta.Tactic.Grind.Parser", + "Lean.Meta.Tactic.Grind.EMatchTheorem", + "Lean.Meta.Tactic.Grind.EMatch", + "Lean.Meta.Tactic.Grind.Main", + "Lean.Meta.Tactic.Grind.CasesMatch", + "Lean.Meta.Tactic.Grind.Arith", + "Lean.Meta.Tactic.Grind.Ext", + "Lean.Meta.Tactic.Grind.MatchCond", + "Lean.Meta.Tactic.Grind.MatchDiscrOnly", + "Lean.Meta.Tactic.Grind.Diseq", + "Lean.Meta.Tactic.Grind.MBTC", + "Lean.Meta.Tactic.Grind.Lookahead" + ] + }, + { + "module": "Lean.Elab.Tactic.Grind", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/Grind.lean", + "source_sha256": "c0e90cdef176f82c948d34178df7a84abb7ae9b2dba9c0cdf85347bd069b549e", + "object_path": "lib/lean/Lean/Elab/Tactic/Grind.olean", + "object_sha256": "c8bb05ab04a512d9c66665e238029054472ff4489c38998910e37937a7f8e259", + "object_bytes": 1827760, + "imports": [ + "Init.Grind.Tactics", + "Lean.Meta.Tactic.Grind", + "Lean.Meta.Tactic.TryThis", + "Lean.Elab.Command", + "Lean.Elab.MutualDef", + "Lean.Elab.Tactic.Basic", + "Lean.Elab.Tactic.Config" + ] + }, + { + "module": "Lean.Meta.Tactic.Try.Collect", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Try/Collect.lean", + "source_sha256": "538a8d4df23623ad41d4d919808a13e89f4aada7ea0506e8e2c1349c5655fef3", + "object_path": "lib/lean/Lean/Meta/Tactic/Try/Collect.olean", + "object_sha256": "567f33f6241d5b328790ad022380cbda11181f36ed20ad86b70b238c67e73b7e", + "object_bytes": 830344, + "imports": [ + "Init.Try", + "Lean.Meta.Tactic.LibrarySearch", + "Lean.Meta.Tactic.Util", + "Lean.Meta.Tactic.Grind.Cases", + "Lean.Meta.Tactic.Grind.EMatchTheorem", + "Lean.Meta.Tactic.FunIndInfo", + "Lean.Meta.Tactic.FunIndCollect" + ] + }, + { + "module": "Lean.Meta.Tactic.Try", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/Try.lean", + "source_sha256": "5c830fddb433f22ac8664daf7f5adf21dc59daa4b884f81cdf4a697e42e555d7", + "object_path": "lib/lean/Lean/Meta/Tactic/Try.olean", + "object_sha256": "312aee6c9710d641f8c9676ceb957c5390da3d44da5b8e79e529223c2514f054", + "object_bytes": 56208, + "imports": [ + "Lean.Meta.Tactic.Try.Collect" + ] + }, + { + "module": "Lean.Elab.Tactic.Try", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/Try.lean", + "source_sha256": "0f34e5eebe7cde1360dd366d30763734423da859630dc05ee0d457ada076f9bb", + "object_path": "lib/lean/Lean/Elab/Tactic/Try.olean", + "object_sha256": "86787710e0d386011f2295a1665848bc176336689477e01d83d0c6af87fee972", + "object_bytes": 2751128, + "imports": [ + "Init.Try", + "Init.Grind.Tactics", + "Lean.Meta.Tactic.ExposeNames", + "Lean.Meta.Tactic.Try", + "Lean.Meta.Tactic.TryThis", + "Lean.Elab.Tactic.Config", + "Lean.Elab.Tactic.SimpTrace", + "Lean.Elab.Tactic.LibrarySearch", + "Lean.Elab.Tactic.Grind" + ] + }, + { + "module": "Lean.Elab.Tactic.AsAuxLemma", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/AsAuxLemma.lean", + "source_sha256": "df34f9900f1c64f57cea804b9eb30b916ad022c22bded1918484d55aae3642b5", + "object_path": "lib/lean/Lean/Elab/Tactic/AsAuxLemma.olean", + "object_sha256": "c0059fe972f7f3414e856f6b715a5d02d23d3d8b2515fdb1754787e3b4581f2c", + "object_bytes": 115384, + "imports": [ + "Init.Tactics", + "Lean.Elab.Tactic.Basic", + "Lean.Elab.Tactic.Meta", + "Lean.MetavarContext", + "Lean.Meta.Closure" + ] + }, + { + "module": "Lean.Elab.Tactic.TreeTacAttr", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/TreeTacAttr.lean", + "source_sha256": "8a805e77e6c16ed1e654619f9c9eaf9b019628161948ab6be8566a2d38ce2092", + "object_path": "lib/lean/Lean/Elab/Tactic/TreeTacAttr.olean", + "object_sha256": "72a257244d228ddf492328fa97b2bd9e236748cd62626fc9583397503d3fd34d", + "object_bytes": 29864, + "imports": [ + "Lean.Meta.Tactic.Simp" + ] + }, + { + "module": "Lean.Elab.Tactic.ExposeNames", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/ExposeNames.lean", + "source_sha256": "df926885a0dd5e9f31cfcdc19d20e28a4d49a8e4c2fde8063f383fc691c085ec", + "object_path": "lib/lean/Lean/Elab/Tactic/ExposeNames.olean", + "object_sha256": "ca44332e2f1f413394f496d49c50968c64c7692a4c5725b163e3b63e6ae2e365", + "object_bytes": 49360, + "imports": [ + "Lean.Meta.Tactic.ExposeNames", + "Lean.Elab.Tactic.Basic" + ] + }, + { + "module": "Lean.Elab.Tactic.SimpArith", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic/SimpArith.lean", + "source_sha256": "4eabacb3789c307c08d50106dfc31220a01be274865089f7a7be0dc9e05eb987", + "object_path": "lib/lean/Lean/Elab/Tactic/SimpArith.olean", + "object_sha256": "da1064f5803e294305469805b5d03f1bcd12e15145f837698d84e0ebe673aad0", + "object_bytes": 183328, + "imports": [ + "Lean.Elab.Tactic.Simp", + "Lean.Meta.Tactic.TryThis" + ] + }, + { + "module": "Lean.Elab.Tactic", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Tactic.lean", + "source_sha256": "67ff612ce3ac8ece09e60d94a0c1fb3e196965ade9b7594e0aa0edba95105d2d", + "object_path": "lib/lean/Lean/Elab/Tactic.olean", + "object_sha256": "388dd52963c24b5f4ec49dad00f29c73d55330dc3346e7195438f210a97cebee", + "object_bytes": 22104, + "imports": [ + "Lean.Elab.Term", + "Lean.Elab.Tactic.Basic", + "Lean.Elab.Tactic.ElabTerm", + "Lean.Elab.Tactic.Induction", + "Lean.Elab.Tactic.Generalize", + "Lean.Elab.Tactic.Injection", + "Lean.Elab.Tactic.Match", + "Lean.Elab.Tactic.Rewrite", + "Lean.Elab.Tactic.Location", + "Lean.Elab.Tactic.SimpTrace", + "Lean.Elab.Tactic.Simp", + "Lean.Elab.Tactic.Simproc", + "Lean.Elab.Tactic.BuiltinTactic", + "Lean.Elab.Tactic.Split", + "Lean.Elab.Tactic.Conv", + "Lean.Elab.Tactic.Delta", + "Lean.Elab.Tactic.Meta", + "Lean.Elab.Tactic.Unfold", + "Lean.Elab.Tactic.Calc", + "Lean.Elab.Tactic.Congr", + "Lean.Elab.Tactic.Guard", + "Lean.Elab.Tactic.RCases", + "Lean.Elab.Tactic.Repeat", + "Lean.Elab.Tactic.Ext", + "Lean.Elab.Tactic.Change", + "Lean.Elab.Tactic.FalseOrByContra", + "Lean.Elab.Tactic.Omega", + "Lean.Elab.Tactic.Simpa", + "Lean.Elab.Tactic.NormCast", + "Lean.Elab.Tactic.Symm", + "Lean.Elab.Tactic.SolveByElim", + "Lean.Elab.Tactic.LibrarySearch", + "Lean.Elab.Tactic.ShowTerm", + "Lean.Elab.Tactic.Rfl", + "Lean.Elab.Tactic.Rewrites", + "Lean.Elab.Tactic.DiscrTreeKey", + "Lean.Elab.Tactic.BVDecide", + "Lean.Elab.Tactic.BoolToPropSimps", + "Lean.Elab.Tactic.Classical", + "Lean.Elab.Tactic.Grind", + "Lean.Elab.Tactic.Monotonicity", + "Lean.Elab.Tactic.Try", + "Lean.Elab.Tactic.AsAuxLemma", + "Lean.Elab.Tactic.TreeTacAttr", + "Lean.Elab.Tactic.ExposeNames", + "Lean.Elab.Tactic.SimpArith", + "Lean.Elab.Tactic.Lets" + ] + }, + { + "module": "Lean.Elab.StructInst", + "root": "lean", + "source_path": "src/lean/Lean/Elab/StructInst.lean", + "source_sha256": "15ce265debc7230973641100d7497009b01ec685f13c23608bc5e21dba50ccb4", + "object_path": "lib/lean/Lean/Elab/StructInst.olean", + "object_sha256": "5b97f22bc7d932c65a28fafce41cab337fae069a900bc689bb4791d37f7a5c9e", + "object_bytes": 5933120, + "imports": [ + "Lean.Util.FindExpr", + "Lean.Parser.Term", + "Lean.Meta.Structure", + "Lean.Elab.App", + "Lean.Elab.Binders", + "Lean.PrettyPrinter" + ] + }, + { + "module": "Lean.Elab.Inductive", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Inductive.lean", + "source_sha256": "b73e39ebc374fc836a0234c9fa761f5aa16eee013ff5cf4c4ecce98d845294a8", + "object_path": "lib/lean/Lean/Elab/Inductive.olean", + "object_sha256": "f16a8591ade27a4380c4d899a9a0d5a61368cf2fb65c26e73bcab85aa2431ed7", + "object_bytes": 1382936, + "imports": [ + "Lean.Elab.MutualInductive" + ] + }, + { + "module": "Lean.Elab.Structure", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Structure.lean", + "source_sha256": "0fe8a09562e88fe94b80bf4a1647ecac75f04e6ccfa5f8d2a1450c868d89ee3b", + "object_path": "lib/lean/Lean/Elab/Structure.olean", + "object_sha256": "21443f31eecea9004bfe2e32ea9cb2c1dea4911366da4514aa431f9843365528", + "object_bytes": 7371536, + "imports": [ + "Lean.Meta.Structure", + "Lean.Elab.MutualInductive" + ] + }, + { + "module": "Lean.Elab.Print", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Print.lean", + "source_sha256": "40997173e15513bb4051163ea70b0b6747df5498c15f984e93acc8df63f687d4", + "object_path": "lib/lean/Lean/Elab/Print.olean", + "object_sha256": "0ad3d727aeae692bcd892b56e2eb45774f1e0f82538a8aee4f1a5fd652276153", + "object_bytes": 1282424, + "imports": [ + "Lean.Meta.Eqns", + "Lean.Util.CollectAxioms", + "Lean.Elab.Command" + ] + }, + { + "module": "Lean.Elab.PreDefinition.WF", + "root": "lean", + "source_path": "src/lean/Lean/Elab/PreDefinition/WF.lean", + "source_sha256": "93b1a0d08a0490df9f96d52b75f785ba8eaef2b66fd36a6528fd7598843cbe09", + "object_path": "lib/lean/Lean/Elab/PreDefinition/WF.olean", + "object_sha256": "6fe2276a67bc681889acfeea24c03eb6ad0cb5262accaf8c7b591ef19a28e485", + "object_bytes": 18032, + "imports": [ + "Lean.Elab.PreDefinition.WF.Main", + "Lean.Elab.PreDefinition.WF.Eqns" + ] + }, + { + "module": "Lean.Elab.PreDefinition.Nonrec.Eqns", + "root": "lean", + "source_path": "src/lean/Lean/Elab/PreDefinition/Nonrec/Eqns.lean", + "source_sha256": "1e1565f2175fcfc74553fb497693f295655b73a97e06974fb3f533e608fed4ee", + "object_path": "lib/lean/Lean/Elab/PreDefinition/Nonrec/Eqns.olean", + "object_sha256": "541c9b078bc86c0813da5f380304a55e0d667c408d5f1839fa61c36694d3fc7f", + "object_bytes": 137664, + "imports": [ + "Lean.Meta.Tactic.Rewrite", + "Lean.Meta.Tactic.Split", + "Lean.Elab.PreDefinition.Basic", + "Lean.Elab.PreDefinition.Eqns", + "Lean.Meta.ArgsPacker.Basic", + "Init.Data.Array.Basic" + ] + }, + { + "module": "Lean.Elab.PreDefinition.EqUnfold", + "root": "lean", + "source_path": "src/lean/Lean/Elab/PreDefinition/EqUnfold.lean", + "source_sha256": "e65334ce33b3148e82b654733ca83da0ef537de7da9151c560f9e515290bd743", + "object_path": "lib/lean/Lean/Elab/PreDefinition/EqUnfold.olean", + "object_sha256": "60fb3491f08af6dd61bd83c0af0a6a32e8c1aac793131f2916408ec582edbc28", + "object_bytes": 316936, + "imports": [ + "Lean.Meta.Eqns", + "Lean.Meta.Tactic.Util", + "Lean.Meta.Tactic.Rfl", + "Lean.Meta.Tactic.Intro", + "Lean.Meta.Tactic.Apply" + ] + }, + { + "module": "Lean.Elab.PreDefinition", + "root": "lean", + "source_path": "src/lean/Lean/Elab/PreDefinition.lean", + "source_sha256": "88f88457b9b087f6f5d7dd3aa4717ae59ee26f62784e8c3e110a9b7bab5f44a4", + "object_path": "lib/lean/Lean/Elab/PreDefinition.olean", + "object_sha256": "42ad4af44de24ae7e1e620707ad27f727ffb8f6d1686684b9075f6f3795f2390", + "object_bytes": 18592, + "imports": [ + "Lean.Elab.PreDefinition.Basic", + "Lean.Elab.PreDefinition.Structural", + "Lean.Elab.PreDefinition.Main", + "Lean.Elab.PreDefinition.MkInhabitant", + "Lean.Elab.PreDefinition.WF", + "Lean.Elab.PreDefinition.Eqns", + "Lean.Elab.PreDefinition.Nonrec.Eqns", + "Lean.Elab.PreDefinition.EqUnfold" + ] + }, + { + "module": "Lean.Elab.Deriving.Util", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Deriving/Util.lean", + "source_sha256": "424f94acaafe8579ad2c4524bafcf7b014de328cbf4755ee71c28142300cea6c", + "object_path": "lib/lean/Lean/Elab/Deriving/Util.olean", + "object_sha256": "2398ffea4b20427e69f260923ab11d23881971f93aa6512adc7febcd057c0d0f", + "object_bytes": 652696, + "imports": [ + "Lean.Parser.Term", + "Lean.Elab.Term" + ] + }, + { + "module": "Lean.Elab.Deriving.Inhabited", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Deriving/Inhabited.lean", + "source_sha256": "eb24279a1e02cc909a4cb63fa2f6c954f586f27d8753e63672924844d46cc162", + "object_path": "lib/lean/Lean/Elab/Deriving/Inhabited.olean", + "object_sha256": "9a76754b285855f5d582ff54a58eb765b0a8476ffbc327ef0c8e536110b3b0a0", + "object_bytes": 991984, + "imports": [ + "Lean.Util.ForEachExprWhere", + "Lean.Elab.Deriving.Basic" + ] + }, + { + "module": "Lean.Elab.Deriving.Nonempty", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Deriving/Nonempty.lean", + "source_sha256": "4d38da4fea40947be297b987b87d0b7ff1327208c11524c60e0d406ba4f6fee7", + "object_path": "lib/lean/Lean/Elab/Deriving/Nonempty.olean", + "object_sha256": "cc1eee88fdb70f365c1d2b4ec2147db37149f595ae1c3698d83f423d4c9fde46", + "object_bytes": 425056, + "imports": [ + "Lean.Elab.Deriving.Basic" + ] + }, + { + "module": "Lean.Elab.Deriving.TypeName", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Deriving/TypeName.lean", + "source_sha256": "b2b942a0f11bbfb0a49358d27a508c5e0e6276d88e9a2d601a12f0c386e5f4a2", + "object_path": "lib/lean/Lean/Elab/Deriving/TypeName.olean", + "object_sha256": "68a7e6a052486ca0d8cb9c8838a30c5f5d82f00b72844288d9014bb64d495c01", + "object_bytes": 278672, + "imports": [ + "Lean.Elab.Deriving.Basic" + ] + }, + { + "module": "Lean.Elab.Deriving.BEq", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Deriving/BEq.lean", + "source_sha256": "417a9d3909e8c1dbf1ea65c510045551d3dc2bc25391e00f81ac038db6ea2980", + "object_path": "lib/lean/Lean/Elab/Deriving/BEq.olean", + "object_sha256": "4151861a1f202177a5ccaa0081e8eb4da311af3764e2ae889bcf08a0229fd450", + "object_bytes": 951352, + "imports": [ + "Lean.Meta.Transform", + "Lean.Elab.Deriving.Basic", + "Lean.Elab.Deriving.Util" + ] + }, + { + "module": "Lean.Meta.Inductive", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Inductive.lean", + "source_sha256": "21cf790eb731c927bf08ad21af1508766d4f8d80194c96b7934356982be620d9", + "object_path": "lib/lean/Lean/Meta/Inductive.olean", + "object_sha256": "f28ebf450a9315af2c1f81e6252e2ba8c9c775332440f1cd4c704785fa5d030b", + "object_bytes": 83856, + "imports": [ + "Lean.Meta.Basic" + ] + }, + { + "module": "Lean.Elab.Deriving.DecEq", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Deriving/DecEq.lean", + "source_sha256": "77e1ef30b3947dcf9fed7d642662bcb57ff9a2855bd3064fc8bac9789cef77d6", + "object_path": "lib/lean/Lean/Elab/Deriving/DecEq.olean", + "object_sha256": "e7ccf3a253ec008af6b6599c0dfdd330ce46fb7df2ceff00baba221b45c49116", + "object_bytes": 1334920, + "imports": [ + "Lean.Meta.Transform", + "Lean.Meta.Inductive", + "Lean.Elab.Deriving.Basic", + "Lean.Elab.Deriving.Util" + ] + }, + { + "module": "Lean.Elab.Deriving.Repr", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Deriving/Repr.lean", + "source_sha256": "295c6b4a50f5fd4add30ecfbbf6c38eca44c321a4567b4da48237035edd98ae3", + "object_path": "lib/lean/Lean/Elab/Deriving/Repr.olean", + "object_sha256": "e9f69b8a469e99f912e1d1eea5fbf3b050ad133d6592e881f69bb461435cc108", + "object_bytes": 931952, + "imports": [ + "Lean.Meta.Transform", + "Lean.Meta.Inductive", + "Lean.Elab.Deriving.Basic", + "Lean.Elab.Deriving.Util" + ] + }, + { + "module": "Lean.Elab.Deriving.FromToJson", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Deriving/FromToJson.lean", + "source_sha256": "0562a7905a56b854c902458caf52a5a4a88d0f23e7b22a0c8030f82729935e38", + "object_path": "lib/lean/Lean/Elab/Deriving/FromToJson.olean", + "object_sha256": "acbbc0328ee1dfa2cc45de0596ebf133d3db40aab3fd643198da7f9482a1cfa6", + "object_bytes": 1733832, + "imports": [ + "Lean.Meta.Transform", + "Lean.Elab.Deriving.Basic", + "Lean.Elab.Deriving.Util", + "Lean.Data.Json.FromToJson" + ] + }, + { + "module": "Lean.Elab.Deriving.SizeOf", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Deriving/SizeOf.lean", + "source_sha256": "5a8d9cc5f98942464c0fb150dd2180235e8019491515e1f76fc5ee1b42ea0c1d", + "object_path": "lib/lean/Lean/Elab/Deriving/SizeOf.olean", + "object_sha256": "bc0d667a0170801fa09ad98f64313d4d36b27bedb97d54c93e3a4a58771b9520", + "object_bytes": 79672, + "imports": [ + "Lean.Meta.SizeOf", + "Lean.Elab.Deriving.Basic" + ] + }, + { + "module": "Lean.Elab.Deriving.Hashable", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Deriving/Hashable.lean", + "source_sha256": "4cd1f97317f1fa81a52030d7cc8e4098bd8f19b9ecbd8f8758b51941eec17350", + "object_path": "lib/lean/Lean/Elab/Deriving/Hashable.olean", + "object_sha256": "bb06f0a338004ef555bedfc792be30c44dbcb11a2798c8a6f4cbea554ffa0798", + "object_bytes": 735504, + "imports": [ + "Lean.Meta.Inductive", + "Lean.Elab.Deriving.Basic", + "Lean.Elab.Deriving.Util" + ] + }, + { + "module": "Lean.Elab.Deriving.Ord", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Deriving/Ord.lean", + "source_sha256": "f2e850f4c41546f6cd7f5560920cb5d8b61eead16ba9861bc8533a23d95d4959", + "object_path": "lib/lean/Lean/Elab/Deriving/Ord.olean", + "object_sha256": "6eec85fc2d862697bf263fb4e4962d367fd3d9908076da839ee6cac3973e732d", + "object_bytes": 813352, + "imports": [ + "Lean.Meta.Transform", + "Lean.Elab.Deriving.Basic", + "Lean.Elab.Deriving.Util" + ] + }, + { + "module": "Lean.Elab.Deriving.ToExpr", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Deriving/ToExpr.lean", + "source_sha256": "e8a5fde0e5484f411f1c22765b7773ae4b0d383f8aeddc027307bb1be48f2608", + "object_path": "lib/lean/Lean/Elab/Deriving/ToExpr.olean", + "object_sha256": "816d1dcf9446457b3be566afae9ce6eaa269f2231ebb9ac7686e356dac9c8a96", + "object_bytes": 1379600, + "imports": [ + "Lean.Meta.Transform", + "Lean.Elab.Deriving.Basic", + "Lean.Elab.Deriving.Util", + "Lean.ToLevel", + "Lean.ToExpr" + ] + }, + { + "module": "Lean.Elab.Deriving", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Deriving.lean", + "source_sha256": "11bdcc5ed3bfaa5351b9c6bef85f9e4d8d12f535a5d7071b05f8f09a7c4ea3fa", + "object_path": "lib/lean/Lean/Elab/Deriving.olean", + "object_sha256": "bc2aa8576925ff56acba3ed5b6967b155e51badb4b9561131286c169f01c9689", + "object_bytes": 19184, + "imports": [ + "Lean.Elab.Deriving.Basic", + "Lean.Elab.Deriving.Util", + "Lean.Elab.Deriving.Inhabited", + "Lean.Elab.Deriving.Nonempty", + "Lean.Elab.Deriving.TypeName", + "Lean.Elab.Deriving.BEq", + "Lean.Elab.Deriving.DecEq", + "Lean.Elab.Deriving.Repr", + "Lean.Elab.Deriving.FromToJson", + "Lean.Elab.Deriving.SizeOf", + "Lean.Elab.Deriving.Hashable", + "Lean.Elab.Deriving.Ord", + "Lean.Elab.Deriving.ToExpr" + ] + }, + { + "module": "Lean.Elab.Extra", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Extra.lean", + "source_sha256": "d6d40f6816bc109287f77a2279ae8ff36fda93b7e4c8a890c87fda412846585f", + "object_path": "lib/lean/Lean/Elab/Extra.olean", + "object_sha256": "58133f13b852f97994b8bbfe38f122f237c3d1f68bd49a73d73ffcb51859ead8", + "object_bytes": 1717424, + "imports": [ + "Lean.Elab.App", + "Lean.Elab.BuiltinNotation" + ] + }, + { + "module": "Lean.Elab.GenInjective", + "root": "lean", + "source_path": "src/lean/Lean/Elab/GenInjective.lean", + "source_sha256": "35bdd3442afaf6041bd7cab3911f4b9ca559d1c172ed3d8253cce72a590fd772", + "object_path": "lib/lean/Lean/Elab/GenInjective.olean", + "object_sha256": "334cf5822211e327c77f908e671d6895571cc8b525c9ab43391e1c2c3afbf9de", + "object_bytes": 56552, + "imports": [ + "Lean.Elab.Command", + "Lean.Meta.Injective" + ] + }, + { + "module": "Lean.Elab.Macro", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Macro.lean", + "source_sha256": "d61571b491611bcab027a5fe134fd5b92b73a010c4932c46729df28889b0946e", + "object_path": "lib/lean/Lean/Elab/Macro.olean", + "object_sha256": "3139e9c2f4a10b1d796dee5669ac32bfbe25fd943933c3932d8b65a9bec42ed6", + "object_bytes": 476272, + "imports": [ + "Lean.Elab.MacroArgUtil" + ] + }, + { + "module": "Lean.Elab.Notation", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Notation.lean", + "source_sha256": "81141a35e3021629a57d66bd31895771a7328732a6f704e74e509344903155ed", + "object_path": "lib/lean/Lean/Elab/Notation.olean", + "object_sha256": "4ac887a2e17bb243e89a84f1ad995bdc4a485a3d4baa86ca56acb0d820755888", + "object_bytes": 810696, + "imports": [ + "Lean.Elab.Syntax", + "Lean.Elab.AuxDef", + "Lean.Elab.BuiltinNotation" + ] + }, + { + "module": "Lean.Elab.Mixfix", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Mixfix.lean", + "source_sha256": "8f6d4cb4e62a560baa8d82110d56c395cb345578bd1618c55b22b1bebbf02f88", + "object_path": "lib/lean/Lean/Elab/Mixfix.olean", + "object_sha256": "02a5b4d9d35072293a293c38439710bb4568462aceeb345945df682f317e20cd", + "object_bytes": 478280, + "imports": [ + "Lean.Elab.Attributes" + ] + }, + { + "module": "Lean.Elab.MacroRules", + "root": "lean", + "source_path": "src/lean/Lean/Elab/MacroRules.lean", + "source_sha256": "7b9821e52a15fcfdafd7ce581e53599f9abb9ffdaf4f379d4353f13dd3762be7", + "object_path": "lib/lean/Lean/Elab/MacroRules.olean", + "object_sha256": "3a2fc8f1c0fbcb7b1643ba4a04741dfaf70c4caf4592a94437a170d8180008e9", + "object_bytes": 599920, + "imports": [ + "Lean.Elab.Syntax", + "Lean.Elab.AuxDef" + ] + }, + { + "module": "Lean.Elab.BuiltinCommand", + "root": "lean", + "source_path": "src/lean/Lean/Elab/BuiltinCommand.lean", + "source_sha256": "b34106690ff7b582471a38154079cfbb561ac2b861baddba3dd4e4abce672058", + "object_path": "lib/lean/Lean/Elab/BuiltinCommand.olean", + "object_sha256": "0d88c7926446d7dc85abbb20b2b4d66c26943c276306ba2a6fbbf263a81b17ea", + "object_bytes": 3133880, + "imports": [ + "Lean.Util.CollectLevelParams", + "Lean.Util.CollectAxioms", + "Lean.Meta.Reduce", + "Lean.Elab.DeclarationRange", + "Lean.Elab.Eval", + "Lean.Elab.Command", + "Lean.Elab.Open", + "Lean.Elab.SetOption", + "Init.System.Platform" + ] + }, + { + "module": "Lean.Elab.BuiltinEvalCommand", + "root": "lean", + "source_path": "src/lean/Lean/Elab/BuiltinEvalCommand.lean", + "source_sha256": "e0ed15983360bd60e24048713e0721a3c7d1e628ebaa6eb1cfb3b514de0ae508", + "object_path": "lib/lean/Lean/Elab/BuiltinEvalCommand.olean", + "object_sha256": "02fa05891b8bb9632a92be4e3e6ad2b7f694aaeca5320c4ed7f0d29aa7f4882f", + "object_bytes": 1672336, + "imports": [ + "Lean.Util.CollectAxioms", + "Lean.Elab.Deriving.Basic", + "Lean.Elab.MutualDef" + ] + }, + { + "module": "Lean.Elab.InheritDoc", + "root": "lean", + "source_path": "src/lean/Lean/Elab/InheritDoc.lean", + "source_sha256": "b04d3dc55c97dabc583a740e03c3728bcb77e66bb57f545482f2811015811c88", + "object_path": "lib/lean/Lean/Elab/InheritDoc.olean", + "object_sha256": "02be75f1bf428edac1ae2554bf3caaf7f8bf0522c63bd3bd8b2c381431b01708", + "object_bytes": 271328, + "imports": [ + "Lean.Elab.InfoTree.Main", + "Lean.DocString.Extension" + ] + }, + { + "module": "Lean.Elab.ParseImportsFast", + "root": "lean", + "source_path": "src/lean/Lean/Elab/ParseImportsFast.lean", + "source_sha256": "2308440ccc46b663374e806fff9f2b6963bd22d3ee462dadbd7dc48828faa150", + "object_path": "lib/lean/Lean/Elab/ParseImportsFast.olean", + "object_sha256": "81a7d7da5d46f7f5a9fab7779346dab400a8051e154aa3a38a589d24a14ea4a9", + "object_bytes": 632984, + "imports": [ + "Lean.Parser.Module" + ] + }, + { + "module": "Lean.Elab.GuardMsgs", + "root": "lean", + "source_path": "src/lean/Lean/Elab/GuardMsgs.lean", + "source_sha256": "73ab3b84f62b5f0775a3cb0644a1f1c9b3a6b2bd99dd833e0b9d1f0d00f42eed", + "object_path": "lib/lean/Lean/Elab/GuardMsgs.olean", + "object_sha256": "fdce3cd07fac641b9a06d1bf565dfa930c195a19922738a6e542fbb0f2d12439", + "object_bytes": 1194752, + "imports": [ + "Lean.Elab.Notation", + "Lean.Util.Diff", + "Lean.Server.CodeActions.Attr" + ] + }, + { + "module": "Lean.Meta.CheckTactic", + "root": "lean", + "source_path": "src/lean/Lean/Meta/CheckTactic.lean", + "source_sha256": "f589c97fe584b0a63b2eecae5af56b97a35e77467978fdf3bec3cd9cc8a82390", + "object_path": "lib/lean/Lean/Meta/CheckTactic.olean", + "object_sha256": "6c8387a5081bfce834343b0eaf253007cc065e5696a8d759fe515400393332f1", + "object_bytes": 110352, + "imports": [ + "Lean.Meta.Basic" + ] + }, + { + "module": "Lean.Elab.CheckTactic", + "root": "lean", + "source_path": "src/lean/Lean/Elab/CheckTactic.lean", + "source_sha256": "eb958cda94dc7aab0b6576bee29ef30dd5159f4522590d3331b1c55f7b2d6716", + "object_path": "lib/lean/Lean/Elab/CheckTactic.olean", + "object_sha256": "68b2d8357fb6c9a9323a69fcac68c7a2e93597faec72d105dc0c2923b026b343", + "object_bytes": 489416, + "imports": [ + "Lean.Elab.Tactic.ElabTerm", + "Lean.Elab.Command", + "Lean.Elab.Tactic.Meta", + "Lean.Meta.CheckTactic" + ] + }, + { + "module": "Lean.Elab.MatchExpr", + "root": "lean", + "source_path": "src/lean/Lean/Elab/MatchExpr.lean", + "source_sha256": "bf007326ccb56bacbb93609ac1244193cd5383eccb5c9b9cdbcbe48a7d1b4944", + "object_path": "lib/lean/Lean/Elab/MatchExpr.olean", + "object_sha256": "a91744453485082ad21d27da9ebf58987e539e2f0154503ea259ac2085723c4b", + "object_bytes": 714232, + "imports": [ + "Lean.Elab.Term" + ] + }, + { + "module": "Lean.Elab.Time", + "root": "lean", + "source_path": "src/lean/Lean/Elab/Time.lean", + "source_sha256": "92ee34d14fe7bdbbecea8792c6f503f6ae4ea3c6f6f13e2ea070ad5aa1389c1a", + "object_path": "lib/lean/Lean/Elab/Time.olean", + "object_sha256": "f023c633ec9f800ae98e423079a5e743ad083f6b2b2ac1706dec345e643b5d85", + "object_bytes": 71520, + "imports": [ + "Lean.Elab.Command" + ] + }, + { + "module": "Lean.Elab.RecommendedSpelling", + "root": "lean", + "source_path": "src/lean/Lean/Elab/RecommendedSpelling.lean", + "source_sha256": "d2adfa38a387ad2020dedb7ebcf0ce5fb2a7ede050eede9b1635f5576f61ebf4", + "object_path": "lib/lean/Lean/Elab/RecommendedSpelling.olean", + "object_sha256": "b8351468589f23afdebf6ff5b13fb0cbcee0cc3ec2d091bc4993c4a521a1c9f9", + "object_bytes": 185416, + "imports": [ + "Lean.Parser.Term.Doc", + "Lean.Parser.Command", + "Lean.Elab.Command" + ] + }, + { + "module": "Lean.Elab.InfoTrees", + "root": "lean", + "source_path": "src/lean/Lean/Elab/InfoTrees.lean", + "source_sha256": "b60d37d9afcead9947cc742befec3f9be22d17b1300ba82ff528d5d4b661b461", + "object_path": "lib/lean/Lean/Elab/InfoTrees.olean", + "object_sha256": "3f2a53b7bbc0d990f6c37a869dc0a2da13a342d58bbc9621bf6d59655c3d2ed5", + "object_bytes": 140096, + "imports": [ + "Lean.Elab.Command" + ] + }, + { + "module": "Lean.Elab", + "root": "lean", + "source_path": "src/lean/Lean/Elab.lean", + "source_sha256": "c7fa7931165aa4eba6dd57e3149584e12a78ca496f75c77b9a4e96d3c76000b6", + "object_path": "lib/lean/Lean/Elab.olean", + "object_sha256": "92b3f84a607d95d32c1a878bfc4c5d0f37ecde475f867c9abe7829528fb2145a", + "object_bytes": 22904, + "imports": [ + "Lean.Elab.Import", + "Lean.Elab.Exception", + "Lean.Elab.Config", + "Lean.Elab.Command", + "Lean.Elab.Term", + "Lean.Elab.App", + "Lean.Elab.Binders", + "Lean.Elab.BinderPredicates", + "Lean.Elab.LetRec", + "Lean.Elab.Frontend", + "Lean.Elab.BuiltinNotation", + "Lean.Elab.Declaration", + "Lean.Elab.Tactic", + "Lean.Elab.Match", + "Lean.Elab.Quotation", + "Lean.Elab.Syntax", + "Lean.Elab.Do", + "Lean.Elab.StructInst", + "Lean.Elab.MutualInductive", + "Lean.Elab.Inductive", + "Lean.Elab.Structure", + "Lean.Elab.Print", + "Lean.Elab.MutualDef", + "Lean.Elab.AuxDef", + "Lean.Elab.PreDefinition", + "Lean.Elab.Deriving", + "Lean.Elab.DeclarationRange", + "Lean.Elab.Extra", + "Lean.Elab.GenInjective", + "Lean.Elab.BuiltinTerm", + "Lean.Elab.Arg", + "Lean.Elab.PatternVar", + "Lean.Elab.ElabRules", + "Lean.Elab.Macro", + "Lean.Elab.Notation", + "Lean.Elab.Mixfix", + "Lean.Elab.MacroRules", + "Lean.Elab.BuiltinCommand", + "Lean.Elab.BuiltinEvalCommand", + "Lean.Elab.RecAppSyntax", + "Lean.Elab.Eval", + "Lean.Elab.Calc", + "Lean.Elab.InheritDoc", + "Lean.Elab.ParseImportsFast", + "Lean.Elab.GuardMsgs", + "Lean.Elab.CheckTactic", + "Lean.Elab.MatchExpr", + "Lean.Elab.Tactic.Doc", + "Lean.Elab.Time", + "Lean.Elab.RecommendedSpelling", + "Lean.Elab.InfoTrees" + ] + }, + { + "module": "Lean.Meta.LevelDefEq", + "root": "lean", + "source_path": "src/lean/Lean/Meta/LevelDefEq.lean", + "source_sha256": "428e0ba5323005aae8a24cc91a78677acceb547efdeb340e5af9e20a77fbbc60", + "object_path": "lib/lean/Lean/Meta/LevelDefEq.olean", + "object_sha256": "8239a689eff1716cd7bd76d0efcf8c8b40e9957ed68f0b40d9a131559afb16a0", + "object_bytes": 684024, + "imports": [ + "Lean.Util.CollectMVars", + "Lean.Meta.Basic", + "Lean.Meta.InferType", + "Lean.Meta.DecLevel" + ] + }, + { + "module": "Lean.Meta.UnificationHint", + "root": "lean", + "source_path": "src/lean/Lean/Meta/UnificationHint.lean", + "source_sha256": "480ae9db691dbc0e8685c646f7ba0c79c18d4d0972697c52318b65ba5f5802af", + "object_path": "lib/lean/Lean/Meta/UnificationHint.olean", + "object_sha256": "8d763061432a42c0de2c1333052339153d5ec28c9ded0498da54ef89761bc48a", + "object_bytes": 957704, + "imports": [ + "Lean.ScopedEnvExtension", + "Lean.Util.Recognizers", + "Lean.Meta.Basic", + "Lean.Meta.DiscrTree", + "Lean.Meta.SynthInstance" + ] + }, + { + "module": "Lean.Meta.ExprDefEq", + "root": "lean", + "source_path": "src/lean/Lean/Meta/ExprDefEq.lean", + "source_sha256": "803a7a4b428a20433527367c88e39282e8b3010bc61e7469a2a3e082c59d0f88", + "object_path": "lib/lean/Lean/Meta/ExprDefEq.olean", + "object_sha256": "33eaa4d1e2a19d568e5028e1659fd2aefa0e30f98e8795c7952fa0a548ff0d9d", + "object_bytes": 6408872, + "imports": [ + "Lean.Meta.Offset", + "Lean.Meta.UnificationHint", + "Lean.Util.OccursCheck" + ] + }, + { + "module": "Lean.Meta.Tactic.AC", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/AC.lean", + "source_sha256": "948fbb190040ef5b7a329fa00efbbf51d62a98bff8d8df68c8ab064c3c3c26e5", + "object_path": "lib/lean/Lean/Meta/Tactic/AC.olean", + "object_sha256": "65cb440bee1de0dc809142922d7b9646e62cee3842ceef3acc049626fcdfb5e3", + "object_bytes": 17920, + "imports": [ + "Lean.Meta.Tactic.AC.Main" + ] + }, + { + "module": "Lean.Meta.Tactic.FunInd", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic/FunInd.lean", + "source_sha256": "74167709c005011a8f1722eead9c39835a6939d7669f3c7e71165eca0d98d458", + "object_path": "lib/lean/Lean/Meta/Tactic/FunInd.olean", + "object_sha256": "9300eb59d6b361d8625f6760eb1eb3d747627f417e39a622c7a2c3723297feec", + "object_bytes": 7068944, + "imports": [ + "Lean.Meta.Basic", + "Lean.Meta.Match.MatcherApp.Transform", + "Lean.Meta.Check", + "Lean.Meta.Tactic.Subst", + "Lean.Meta.Injective", + "Lean.Meta.ArgsPacker", + "Lean.Meta.PProdN", + "Lean.Elab.PreDefinition.WF.Eqns", + "Lean.Elab.PreDefinition.Structural.Eqns", + "Lean.Elab.PreDefinition.Structural.IndGroupInfo", + "Lean.Elab.PreDefinition.Structural.FindRecArg", + "Lean.Elab.Command", + "Lean.Meta.Tactic.ElimInfo", + "Lean.Meta.Tactic.FunIndInfo" + ] + }, + { + "module": "Lean.Meta.Tactic", + "root": "lean", + "source_path": "src/lean/Lean/Meta/Tactic.lean", + "source_sha256": "59ab7849e737317536401e40c249ac19ec3b05bd34f80c2c13dd9a9673421d6c", + "object_path": "lib/lean/Lean/Meta/Tactic.olean", + "object_sha256": "40b83b376c0ccffaac302a208c591e817d523899359f95928d5f2251f84c183d", + "object_bytes": 21608, + "imports": [ + "Lean.Meta.Tactic.Intro", + "Lean.Meta.Tactic.Assumption", + "Lean.Meta.Tactic.Contradiction", + "Lean.Meta.Tactic.Apply", + "Lean.Meta.Tactic.Revert", + "Lean.Meta.Tactic.Clear", + "Lean.Meta.Tactic.Assert", + "Lean.Meta.Tactic.Rewrite", + "Lean.Meta.Tactic.Generalize", + "Lean.Meta.Tactic.Replace", + "Lean.Meta.Tactic.Lets", + "Lean.Meta.Tactic.Induction", + "Lean.Meta.Tactic.Cases", + "Lean.Meta.Tactic.ElimInfo", + "Lean.Meta.Tactic.Delta", + "Lean.Meta.Tactic.Constructor", + "Lean.Meta.Tactic.Simp", + "Lean.Meta.Tactic.AuxLemma", + "Lean.Meta.Tactic.SplitIf", + "Lean.Meta.Tactic.Split", + "Lean.Meta.Tactic.TryThis", + "Lean.Meta.Tactic.Cleanup", + "Lean.Meta.Tactic.Unfold", + "Lean.Meta.Tactic.Rename", + "Lean.Meta.Tactic.AC", + "Lean.Meta.Tactic.Refl", + "Lean.Meta.Tactic.Congr", + "Lean.Meta.Tactic.Repeat", + "Lean.Meta.Tactic.NormCast", + "Lean.Meta.Tactic.IndependentOf", + "Lean.Meta.Tactic.Symm", + "Lean.Meta.Tactic.Backtrack", + "Lean.Meta.Tactic.SolveByElim", + "Lean.Meta.Tactic.FunInd", + "Lean.Meta.Tactic.Rfl", + "Lean.Meta.Tactic.Rewrites", + "Lean.Meta.Tactic.Grind", + "Lean.Meta.Tactic.Ext", + "Lean.Meta.Tactic.Try" + ] + }, + { + "module": "Lean.Meta.ExprLens", + "root": "lean", + "source_path": "src/lean/Lean/Meta/ExprLens.lean", + "source_sha256": "9662f945f82600e650425f2ba392e7fad3d42fc3c912808ed7965d7443ac1d8a", + "object_path": "lib/lean/Lean/Meta/ExprLens.olean", + "object_sha256": "22de5a377e385ab4bbe988b22a41ee447bd26de421000ee177d714d040986d3f", + "object_bytes": 915944, + "imports": [ + "Lean.Meta.Basic", + "Lean.SubExpr" + ] + }, + { + "module": "Lean.Meta.ExprTraverse", + "root": "lean", + "source_path": "src/lean/Lean/Meta/ExprTraverse.lean", + "source_sha256": "b8777c4bff32ddc8f6a34959e127f6323c9d2b8af5b2c3d02d9cd15d50416160", + "object_path": "lib/lean/Lean/Meta/ExprTraverse.olean", + "object_sha256": "3f0f84c7de065e3589e3f01a392a9410473ae286e4b91fc4c41b1fbde724d217", + "object_bytes": 249328, + "imports": [ + "Lean.Meta.Basic", + "Lean.SubExpr" + ] + }, + { + "module": "Lean.Meta", + "root": "lean", + "source_path": "src/lean/Lean/Meta.lean", + "source_sha256": "56e36446401e9c5cb8472e0f12be93be0e7309adb43071b5eda018476721c6ec", + "object_path": "lib/lean/Lean/Meta.olean", + "object_sha256": "640c1a56806da62b8f661685a6038f69e23cea7724d0f39cb6104900b31dc143", + "object_bytes": 23088, + "imports": [ + "Lean.Meta.Basic", + "Lean.Meta.LevelDefEq", + "Lean.Meta.WHNF", + "Lean.Meta.InferType", + "Lean.Meta.FunInfo", + "Lean.Meta.ExprDefEq", + "Lean.Meta.DecLevel", + "Lean.Meta.DiscrTree", + "Lean.Meta.Reduce", + "Lean.Meta.Instances", + "Lean.Meta.AbstractMVars", + "Lean.Meta.SynthInstance", + "Lean.Meta.AppBuilder", + "Lean.Meta.Sorry", + "Lean.Meta.Tactic", + "Lean.Meta.KAbstract", + "Lean.Meta.RecursorInfo", + "Lean.Meta.GeneralizeTelescope", + "Lean.Meta.Match", + "Lean.Meta.ReduceEval", + "Lean.Meta.Closure", + "Lean.Meta.AbstractNestedProofs", + "Lean.Meta.ForEachExpr", + "Lean.Meta.Transform", + "Lean.Meta.PPGoal", + "Lean.Meta.UnificationHint", + "Lean.Meta.Inductive", + "Lean.Meta.SizeOf", + "Lean.Meta.IndPredBelow", + "Lean.Meta.Coe", + "Lean.Meta.CollectFVars", + "Lean.Meta.GeneralizeVars", + "Lean.Meta.Injective", + "Lean.Meta.Structure", + "Lean.Meta.Constructions", + "Lean.Meta.CongrTheorems", + "Lean.Meta.Eqns", + "Lean.Meta.ExprLens", + "Lean.Meta.ExprTraverse", + "Lean.Meta.Eval", + "Lean.Meta.CoeAttr", + "Lean.Meta.Iterator", + "Lean.Meta.LazyDiscrTree", + "Lean.Meta.LitValues", + "Lean.Meta.CheckTactic", + "Lean.Meta.Canonicalizer", + "Lean.Meta.Diagnostics", + "Lean.Meta.BinderNameHint", + "Lean.Meta.TryThis", + "Lean.Meta.Hint" + ] + }, + { + "module": "Lean.Util.TestExtern", + "root": "lean", + "source_path": "src/lean/Lean/Util/TestExtern.lean", + "source_sha256": "db616aa10808cbb373b4f7efecb238d405681e1081e9f62e5418dc5e00fd1d7c", + "object_path": "lib/lean/Lean/Util/TestExtern.olean", + "object_sha256": "cab52888ccce3e83160e1ae1648e3945f59b8764a960016444cf27fbb65533f4", + "object_bytes": 175752, + "imports": [ + "Lean.Elab.SyntheticMVars", + "Lean.Elab.Command", + "Lean.Meta.Tactic.Unfold", + "Lean.Meta.Eval", + "Lean.Compiler.ImplementedByAttr" + ] + }, + { + "module": "Lean.Util.FileSetupInfo", + "root": "lean", + "source_path": "src/lean/Lean/Util/FileSetupInfo.lean", + "source_sha256": "0bd9d92734eed78ce55b4e7206c419134636c308d6b424010e43de5be396670b", + "object_path": "lib/lean/Lean/Util/FileSetupInfo.olean", + "object_sha256": "f6f4b651f77393dd6cee609792cc2cca35fc242d00d15904568909f1f01e397b", + "object_bytes": 100984, + "imports": [ + "Lean.Util.LeanOptions" + ] + }, + { + "module": "Lean.Util.SearchPath", + "root": "lean", + "source_path": "src/lean/Lean/Util/SearchPath.lean", + "source_sha256": "b8f920d6331a8a4b876ff2fea89c11e59db7eea8220b5be373820beebe13a9ce", + "object_path": "lib/lean/Lean/Util/SearchPath.olean", + "object_sha256": "1c4919f7647237f66cedc0a4075e3f7b6c18f87b269cd06f79483da1595cafb2", + "object_bytes": 89840, + "imports": [ + "Lean.ToExpr", + "Lean.Util.Path", + "Lean.Elab.Term" + ] + }, + { + "module": "Lean.Util", + "root": "lean", + "source_path": "src/lean/Lean/Util.lean", + "source_sha256": "8b3c614917f01b9936d158ea7f8d5f8e86b912f3655a73004ddecaae7247eceb", + "object_path": "lib/lean/Lean/Util.olean", + "object_sha256": "7947487118b69bcf58a2f34403ce7e758c01b87ed09107d1f5627a33788b9747", + "object_bytes": 21336, + "imports": [ + "Lean.Util.CollectFVars", + "Lean.Util.CollectLevelParams", + "Lean.Util.CollectMVars", + "Lean.Util.CollectLevelMVars", + "Lean.Util.FindMVar", + "Lean.Util.FindLevelMVar", + "Lean.Util.MonadCache", + "Lean.Util.PPExt", + "Lean.Util.Path", + "Lean.Util.Profile", + "Lean.Util.RecDepth", + "Lean.Util.ShareCommon", + "Lean.Util.Sorry", + "Lean.Util.Trace", + "Lean.Util.FindExpr", + "Lean.Util.ReplaceExpr", + "Lean.Util.ForEachExpr", + "Lean.Util.ForEachExprWhere", + "Lean.Util.ReplaceLevel", + "Lean.Util.FoldConsts", + "Lean.Util.SCC", + "Lean.Util.TestExtern", + "Lean.Util.OccursCheck", + "Lean.Util.HasConstCache", + "Lean.Util.FileSetupInfo", + "Lean.Util.Heartbeats", + "Lean.Util.SearchPath", + "Lean.Util.SafeExponentiation", + "Lean.Util.NumObjs", + "Lean.Util.NumApps", + "Lean.Util.FVarSubset", + "Lean.Util.SortExprs" + ] + }, + { + "module": "Lean.Server.Watchdog", + "root": "lean", + "source_path": "src/lean/Lean/Server/Watchdog.lean", + "source_sha256": "3bc961f6e4bd394775023d9cf0a95008ea25fefb3f3415c01e1fb9146eb75ab4", + "object_path": "lib/lean/Lean/Server/Watchdog.olean", + "object_sha256": "a891e0b66e8a7b359d76158f0da8ed424df16c1fd47cb8e63151ff456bc3d8d2", + "object_bytes": 4662424, + "imports": [ + "Init.System.IO", + "Std.Sync.Mutex", + "Std.Data.TreeMap", + "Init.Data.ByteArray", + "Lean.Data.RBMap", + "Lean.Util.Paths", + "Lean.Data.FuzzyMatching", + "Lean.Data.Json", + "Lean.Data.Lsp", + "Lean.Server.Utils", + "Lean.Server.Requests", + "Lean.Server.References", + "Lean.Server.ServerTask", + "Lean.Server.Completion.CompletionUtils", + "Init.Data.List.Sort" + ] + }, + { + "module": "Std.Internal.Async.Basic", + "root": "lean", + "source_path": "src/lean/Std/Internal/Async/Basic.lean", + "source_sha256": "639b6d00d85e91d6f5cdb14a959ccb80f747ac4bd23fa4a28e6009e3c17724f2", + "object_path": "lib/lean/Std/Internal/Async/Basic.olean", + "object_sha256": "8c58bb13698bb0f52e48d5ec321ad45e4c806c5f6f83760320979d848b6f35e5", + "object_bytes": 91592, + "imports": [ + "Init.Core", + "Init.System.IO", + "Init.System.Promise" + ] + }, + { + "module": "Std.Internal.Async.Select", + "root": "lean", + "source_path": "src/lean/Std/Internal/Async/Select.lean", + "source_sha256": "4b57c5fc64b319d5db2c11bbe7a1a525b36f843807985a7122ade78d3815d917", + "object_path": "lib/lean/Std/Internal/Async/Select.olean", + "object_sha256": "b99a1a319d20c9351fb25bd7d81355388cbf3210070f81c5620adea629dec44f", + "object_bytes": 421808, + "imports": [ + "Init.Data.Array.Basic", + "Init.Data.Random", + "Std.Internal.Async.Basic" + ] + }, + { + "module": "Std.Sync.Channel", + "root": "lean", + "source_path": "src/lean/Std/Sync/Channel.lean", + "source_sha256": "df926df9b8d7c011948e61982d6db08687bf3a8699e85c820524190a51cb2501", + "object_path": "lib/lean/Std/Sync/Channel.olean", + "object_sha256": "5cff8c6e3651ff9add9079232aa599662342cc358431bc0de82777aa0647c95e", + "object_bytes": 1802584, + "imports": [ + "Init.System.Promise", + "Init.Data.Queue", + "Std.Sync.Mutex", + "Std.Internal.Async.Select" + ] + }, + { + "module": "Lean.Server.FileWorker.WidgetRequests", + "root": "lean", + "source_path": "src/lean/Lean/Server/FileWorker/WidgetRequests.lean", + "source_sha256": "6515648db929560feac80a562ff210a91845afc99a7d453318f2b034a41c573a", + "object_path": "lib/lean/Lean/Server/FileWorker/WidgetRequests.olean", + "object_sha256": "0050f686574043bc5f15291d11c3e753e37113de4259a0e097f84bfd03aa0670", + "object_bytes": 736632, + "imports": [ + "Lean.Widget.Basic", + "Lean.Widget.InteractiveCode", + "Lean.Widget.InteractiveGoal", + "Lean.Widget.InteractiveDiagnostic", + "Lean.Server.Rpc.RequestHandling", + "Lean.Server.FileWorker.RequestHandling" + ] + }, + { + "module": "Lean.Util.LakePath", + "root": "lean", + "source_path": "src/lean/Lean/Util/LakePath.lean", + "source_sha256": "060d8547ffc1d2e4e89a66caadac523b4b4614acfd97c77c44488c9ed5340112", + "object_path": "lib/lean/Lean/Util/LakePath.olean", + "object_sha256": "d0684028a7192b7a28d9f9b7528bccf42680bf090aa16e5394c3e9a50e6b6fda", + "object_bytes": 51776, + "imports": [ + "Init.System.IO" + ] + }, + { + "module": "Lean.Server.FileWorker.SetupFile", + "root": "lean", + "source_path": "src/lean/Lean/Server/FileWorker/SetupFile.lean", + "source_sha256": "139f377949f15d5c50d5bdb56c6cd6fe4dddf15e92ca0b295700a29444f7e1d4", + "object_path": "lib/lean/Lean/Server/FileWorker/SetupFile.olean", + "object_sha256": "abadd302a2215c46ad35ff245ae2ac1b5b12349b45f47afaa47e222c325ea2c3", + "object_bytes": 311160, + "imports": [ + "Init.System.IO", + "Lean.Server.Utils", + "Lean.Util.FileSetupInfo", + "Lean.Util.LakePath", + "Lean.LoadDynlib", + "Lean.Server.ServerTask" + ] + }, + { + "module": "Lean.Server.Completion.ImportCompletion", + "root": "lean", + "source_path": "src/lean/Lean/Server/Completion/ImportCompletion.lean", + "source_sha256": "8321f897d10419415709ddebbe3e584a6464936fead6590dd8efce0bbd977fb8", + "object_path": "lib/lean/Lean/Server/Completion/ImportCompletion.olean", + "object_sha256": "a8f40a6c6fde92430a312f4b06687104b99a899fd3f20ae2ebd823cf27a2fd4a", + "object_bytes": 478704, + "imports": [ + "Lean.Data.NameTrie", + "Lean.Util.Paths", + "Lean.Util.LakePath", + "Lean.Server.Completion.CompletionItemData", + "Lean.Parser.Module" + ] + }, + { + "module": "Lean.Server.CodeActions.UnknownIdentifier", + "root": "lean", + "source_path": "src/lean/Lean/Server/CodeActions/UnknownIdentifier.lean", + "source_sha256": "30033c191d4124bb53583f77f5fa2647aca500dba3a6430b306d04e11fb08bf8", + "object_path": "lib/lean/Lean/Server/CodeActions/UnknownIdentifier.olean", + "object_sha256": "9d198314044e65bb1308e196ac21460df249b0e50e7a4145ab25387b074bbf25", + "object_bytes": 970824, + "imports": [ + "Lean.Server.FileWorker.Utils", + "Lean.Data.Lsp.Internal", + "Lean.Server.Requests", + "Lean.Server.Completion.CompletionInfoSelection", + "Lean.Server.CodeActions.Basic", + "Lean.Server.Completion.CompletionUtils" + ] + }, + { + "module": "Lean.Server.FileWorker", + "root": "lean", + "source_path": "src/lean/Lean/Server/FileWorker.lean", + "source_sha256": "3d1d2524419b8fae19d240b7fac1a7c45999195ef33cb2bc68d6035f94d5d5d0", + "object_path": "lib/lean/Lean/Server/FileWorker.olean", + "object_sha256": "1a2740ff2f65aace8a01f26c4b62ff2f206a533e654bc9b30572e229105bdf93", + "object_bytes": 3244072, + "imports": [ + "Init.System.IO", + "Std.Sync.Channel", + "Lean.Data.RBMap", + "Lean.Environment", + "Lean.Data.Lsp", + "Lean.Data.Json.FromToJson", + "Lean.Util.FileSetupInfo", + "Lean.LoadDynlib", + "Lean.Language.Lean", + "Lean.Server.Utils", + "Lean.Server.AsyncList", + "Lean.Server.References", + "Lean.Server.FileWorker.Utils", + "Lean.Server.FileWorker.RequestHandling", + "Lean.Server.FileWorker.WidgetRequests", + "Lean.Server.FileWorker.SetupFile", + "Lean.Server.Rpc.Basic", + "Lean.Widget.InteractiveDiagnostic", + "Lean.Server.Completion.ImportCompletion", + "Lean.Server.CodeActions.UnknownIdentifier" + ] + }, + { + "module": "Lean.Server.Rpc.Deriving", + "root": "lean", + "source_path": "src/lean/Lean/Server/Rpc/Deriving.lean", + "source_sha256": "91297b0f388487efd78567a963bdde57b22b09a5f305f1a551576c59fbddab22", + "object_path": "lib/lean/Lean/Server/Rpc/Deriving.olean", + "object_sha256": "aa8a5a9cc0bcf7149d7e6cfad5502d4a0d971f5f51fdfaa39cc0a2f99674af91", + "object_bytes": 1454664, + "imports": [ + "Lean.Elab.Command", + "Lean.Elab.Term", + "Lean.Elab.Deriving.Basic", + "Lean.Server.Rpc.Basic" + ] + }, + { + "module": "Lean.Server.Rpc", + "root": "lean", + "source_path": "src/lean/Lean/Server/Rpc.lean", + "source_sha256": "78a66206dcbab54d8cb1fb09a84b2facacccc5eb501dcff48881b822732213a7", + "object_path": "lib/lean/Lean/Server/Rpc.olean", + "object_sha256": "417cd960816e8c474ad467cbd1656f63601cad2445717d112b062d89203f106d", + "object_bytes": 18112, + "imports": [ + "Lean.Server.Rpc.Basic", + "Lean.Server.Rpc.Deriving", + "Lean.Server.Rpc.RequestHandling" + ] + }, + { + "module": "Lean.Server.Test.Cancel", + "root": "lean", + "source_path": "src/lean/Lean/Server/Test/Cancel.lean", + "source_sha256": "bc4d6af7573a597b3c32df1d6c5debec12df735cb774473e5c6142fa91c5c1a8", + "object_path": "lib/lean/Lean/Server/Test/Cancel.olean", + "object_sha256": "9e2a230300c5ac17dc7db71b84bb6bf2539bc91d3f83e0274f100c2e1a39134f", + "object_bytes": 503168, + "imports": [ + "Lean.Elab.Tactic.Basic" + ] + }, + { + "module": "Lean.Widget", + "root": "lean", + "source_path": "src/lean/Lean/Widget.lean", + "source_sha256": "fd2551b4d71e862d5fda688b44f6793fefeed461ae67714246a3b48061da326c", + "object_path": "lib/lean/Lean/Widget.olean", + "object_sha256": "ea653d3251adc5f5dba5d44bbb31cd31261caebc10f8d7dbac2371b071876f47", + "object_bytes": 18280, + "imports": [ + "Lean.Widget.InteractiveCode", + "Lean.Widget.InteractiveDiagnostic", + "Lean.Widget.InteractiveGoal", + "Lean.Widget.TaggedText", + "Lean.Widget.UserWidget" + ] + }, + { + "module": "Lean.Server.Test.Runner", + "root": "lean", + "source_path": "src/lean/Lean/Server/Test/Runner.lean", + "source_sha256": "7c64de2ac71dde8664814dde80377f959cb07af5e8f1cfedd662fcbc06c3eb46", + "object_path": "lib/lean/Lean/Server/Test/Runner.olean", + "object_sha256": "fae147d94f3055fb2244517d098b6beb3d13a63f58fa7d18ddc2532d8bbf4754", + "object_bytes": 1504592, + "imports": [ + "Lean.Data.Lsp", + "Lean.Widget" + ] + }, + { + "module": "Lean.Server.Test", + "root": "lean", + "source_path": "src/lean/Lean/Server/Test.lean", + "source_sha256": "aaaf2338898ed08e7feae3f0da9f81cd68997171395b16695c49f17f8b25c3cb", + "object_path": "lib/lean/Lean/Server/Test.olean", + "object_sha256": "74b958ac4da56986dbdd235de4cebe8630edc3cd2d621cce5b4b934bdeb7439c", + "object_bytes": 17992, + "imports": [ + "Lean.Server.Test.Cancel", + "Lean.Server.Test.Runner" + ] + }, + { + "module": "Lean.Server", + "root": "lean", + "source_path": "src/lean/Lean/Server.lean", + "source_sha256": "f57f7b2697969d4975fca8a41eeecfe77fb378fe91cd229071b84bac497b1b53", + "object_path": "lib/lean/Lean/Server.olean", + "object_sha256": "13c2ec83f8c4e053e402e50052052e16da289fd2dd50ed12939a4c944e5f4f13", + "object_bytes": 18256, + "imports": [ + "Lean.Server.Watchdog", + "Lean.Server.FileWorker", + "Lean.Server.Rpc", + "Lean.Server.CodeActions", + "Lean.Server.Test" + ] + }, + { + "module": "Lean.Linter.Builtin", + "root": "lean", + "source_path": "src/lean/Lean/Linter/Builtin.lean", + "source_sha256": "0d592b33567cf286c3af632b30c0265a0b22e2af4499e432d3c796591ed6e8df", + "object_path": "lib/lean/Lean/Linter/Builtin.olean", + "object_sha256": "bd2bec4112b7241afbc8dbf2bae81298cc3a354471c8b0f6a6d519ba8fec42da", + "object_bytes": 286800, + "imports": [ + "Lean.Linter.Util", + "Lean.Elab.Command" + ] + }, + { + "module": "Lean.Linter.ConstructorAsVariable", + "root": "lean", + "source_path": "src/lean/Lean/Linter/ConstructorAsVariable.lean", + "source_sha256": "96dba086c8149713cfb1e4a66e7028a98f44bb0e88525c928cc015df6ce9a53b", + "object_path": "lib/lean/Lean/Linter/ConstructorAsVariable.olean", + "object_sha256": "b763f4e2068965c9f2e7e0d6a0d2b2e0fa37e1d12e1fce4fa7d89ace55329192", + "object_bytes": 488688, + "imports": [ + "Lean.Elab.Command", + "Lean.Linter.Util" + ] + }, + { + "module": "Lean.Linter.Omit", + "root": "lean", + "source_path": "src/lean/Lean/Linter/Omit.lean", + "source_sha256": "e3781a6cb2fd58d8440a186ea37d4029d434665767fabc9976834b3dec03ee68", + "object_path": "lib/lean/Lean/Linter/Omit.olean", + "object_sha256": "9f791a72b0a5d93bbcc9594681ece736513f0187e9921d289d05d6833b31534d", + "object_bytes": 80096, + "imports": [ + "Lean.Elab.Command", + "Lean.Linter.Util" + ] + }, + { + "module": "Lean.Linter.List", + "root": "lean", + "source_path": "src/lean/Lean/Linter/List.lean", + "source_sha256": "e79a8b07efd9ec86ae4b933128e712e287fc409c45005afb681d948d1978f700", + "object_path": "lib/lean/Lean/Linter/List.olean", + "object_sha256": "423c4ab9b9f671305f057bde9a4cbcbb5573b25698121c5ce3b4c2079601a679", + "object_bytes": 1001536, + "imports": [ + "Lean.Elab.Command", + "Lean.Server.InfoUtils" + ] + }, + { + "module": "Lean.Linter.Sets", + "root": "lean", + "source_path": "src/lean/Lean/Linter/Sets.lean", + "source_sha256": "5c42b999d5a24c9741355996a8b84d510889085c7ef623f5aec4d178ed3cc3df", + "object_path": "lib/lean/Lean/Linter/Sets.olean", + "object_sha256": "40534d496258131a60924bb3cccee750e867e3e0d8831480f2e7091fb7ab7b01", + "object_bytes": 258112, + "imports": [ + "Lean.Elab.Command", + "Lean.Linter.Basic" + ] + }, + { + "module": "Lean.Linter", + "root": "lean", + "source_path": "src/lean/Lean/Linter.lean", + "source_sha256": "8bd8693c1447bd899f459446ab28b640a4f25c96ee47725ffbf88b85a90ec2f9", + "object_path": "lib/lean/Lean/Linter.olean", + "object_sha256": "4549cae37df80d0d0e50a97ea59862da177563533d1306a72c6efa52d6a90e0b", + "object_bytes": 18608, + "imports": [ + "Lean.Linter.Util", + "Lean.Linter.Builtin", + "Lean.Linter.ConstructorAsVariable", + "Lean.Linter.Deprecated", + "Lean.Linter.UnusedVariables", + "Lean.Linter.MissingDocs", + "Lean.Linter.Omit", + "Lean.Linter.List", + "Lean.Linter.Sets" + ] + }, + { + "module": "Lean.Replay", + "root": "lean", + "source_path": "src/lean/Lean/Replay.lean", + "source_sha256": "98befab0c3f017c7afcd847990fcca99988937df313b28ef04fcf4375560d16b", + "object_path": "lib/lean/Lean/Replay.olean", + "object_sha256": "c454f93aa3bce90f1736e3d0f481912309c6d019b6e6b281e961c69d2af76ae0", + "object_bytes": 581440, + "imports": [ + "Lean.CoreM", + "Lean.AddDecl", + "Lean.Util.FoldConsts" + ] + }, + { + "module": "Lean.PremiseSelection", + "root": "lean", + "source_path": "src/lean/Lean/PremiseSelection.lean", + "source_sha256": "2eb12b7b10a5588a6a1f94188aab69386bf136e6fed38a0d95451ab9bdad8daa", + "object_path": "lib/lean/Lean/PremiseSelection.olean", + "object_sha256": "f121723064e23494ce5832d979186b442b25378f1509291c237930e6de70499f", + "object_bytes": 328352, + "imports": [ + "Lean.Elab.Command", + "Lean.Meta.Eval", + "Lean.Meta.CompletionName", + "Init.Data.Random" + ] + }, + { + "module": "Lean", + "root": "lean", + "source_path": "src/lean/Lean.lean", + "source_sha256": "ff33c6edabf66f62f10912f3f7df844c889482a65ac091965940b706990fddd8", + "object_path": "lib/lean/Lean.olean", + "object_sha256": "34aafa1c71f5f8050964b9e84cd67a39ffdfc4546142c1342fee8d0e52910357", + "object_bytes": 21312, + "imports": [ + "Init", + "Lean.Data", + "Lean.Compiler", + "Lean.Environment", + "Lean.Modifiers", + "Lean.ProjFns", + "Lean.Runtime", + "Lean.ResolveName", + "Lean.Attributes", + "Lean.Parser", + "Lean.ReducibilityAttrs", + "Lean.Elab", + "Lean.Class", + "Lean.LocalContext", + "Lean.MetavarContext", + "Lean.AuxRecursor", + "Lean.Meta", + "Lean.Util", + "Lean.Structure", + "Lean.PrettyPrinter", + "Lean.CoreM", + "Lean.ReservedNameAction", + "Lean.InternalExceptionId", + "Lean.Server", + "Lean.ScopedEnvExtension", + "Lean.DocString", + "Lean.DeclarationRange", + "Lean.LoadDynlib", + "Lean.Widget", + "Lean.Log", + "Lean.Linter", + "Lean.SubExpr", + "Lean.LabelAttribute", + "Lean.AddDecl", + "Lean.Replay", + "Lean.PrivateName", + "Lean.PremiseSelection", + "Lean.Namespace", + "Lean.EnvExtension" + ] + }, + { + "module": "Mathlib.Tactic.Linter.DirectoryDependency", + "root": "mathlib", + "source_path": "Mathlib/Tactic/Linter/DirectoryDependency.lean", + "source_sha256": "c5583ed89719281c69f8713d851e746c191b444830318d35acebb6fa6abc5a41", + "object_path": ".lake/build/lib/lean/Mathlib/Tactic/Linter/DirectoryDependency.olean", + "object_sha256": "0b4586f9284498598eca82a846adb175d2143912e040ea1e1fb5293c2c3b72a2", + "object_bytes": 1246896, + "imports": [ + "Init", + "Lean.Elab.Command", + "Lean.Elab.ParseImportsFast" + ] + }, + { + "module": "Mathlib.Tactic.Linter.Header", + "root": "mathlib", + "source_path": "Mathlib/Tactic/Linter/Header.lean", + "source_sha256": "2cd0ffb71390648275d7e564316c681522002af5d8580eec6e2fcd5a0a7de295", + "object_path": ".lake/build/lib/lean/Mathlib/Tactic/Linter/Header.olean", + "object_sha256": "196662bf58599fd2121928225408130f39ce15ea7ae089c9e39ff3ecdf923c27", + "object_bytes": 843584, + "imports": [ + "Init", + "Lean.Elab.Command", + "Lean.Elab.ParseImportsFast", + "Mathlib.Tactic.Linter.DirectoryDependency" + ] + }, + { + "module": "Mathlib.Tactic.Linter.CommandStart", + "root": "mathlib", + "source_path": "Mathlib/Tactic/Linter/CommandStart.lean", + "source_sha256": "b33687c53127a862052d7d8e692966c695c11760430758e1f7efe430ebb04be9", + "object_path": ".lake/build/lib/lean/Mathlib/Tactic/Linter/CommandStart.olean", + "object_sha256": "6df3332e4178359e90e0aa3be22a8f907561f7395713d59509624bd52aa830ce", + "object_bytes": 975840, + "imports": [ + "Init", + "Mathlib.Tactic.Linter.Header" + ] + }, + { + "module": "Mathlib.Tactic.Linter.DeprecatedSyntaxLinter", + "root": "mathlib", + "source_path": "Mathlib/Tactic/Linter/DeprecatedSyntaxLinter.lean", + "source_sha256": "33034d16d8ba4304134ad8a33e78e5ad275e770ac91b816b8a1173afb4ea98f0", + "object_path": ".lake/build/lib/lean/Mathlib/Tactic/Linter/DeprecatedSyntaxLinter.olean", + "object_sha256": "36f72ab6d23b26a27fd3daac226c56a57a184c0e182cf3c448c674d0b76765f7", + "object_bytes": 563872, + "imports": [ + "Init", + "Lean.Elab.Command", + "Mathlib.Tactic.Linter.Header" + ] + }, + { + "module": "Mathlib.Tactic.Linter.DocPrime", + "root": "mathlib", + "source_path": "Mathlib/Tactic/Linter/DocPrime.lean", + "source_sha256": "a34a375d0481abe7a6bbbadbc4147cc5d4615313ae3a60b217818cc0c82c28e5", + "object_path": ".lake/build/lib/lean/Mathlib/Tactic/Linter/DocPrime.olean", + "object_sha256": "bdced11956f89a02f3eecee7ec36df9c9ce3ea7494d0724d93e5cd172e4e0b03", + "object_bytes": 197064, + "imports": [ + "Init", + "Lean.Elab.Command", + "Mathlib.Tactic.Linter.Header" + ] + }, + { + "module": "Mathlib.Tactic.Linter.DocString", + "root": "mathlib", + "source_path": "Mathlib/Tactic/Linter/DocString.lean", + "source_sha256": "b9744f841ad2a3e6518374c895763d519321f24df4bec31c426b8d648d010ada", + "object_path": ".lake/build/lib/lean/Mathlib/Tactic/Linter/DocString.olean", + "object_sha256": "4d6e5f616d7cd147fe84ae9f700cbb64f6002619e9d8444c4173d4ff7e50ee8a", + "object_bytes": 383064, + "imports": [ + "Init", + "Mathlib.Tactic.Linter.Header" + ] + }, + { + "module": "Mathlib.Tactic.Linter.GlobalAttributeIn", + "root": "mathlib", + "source_path": "Mathlib/Tactic/Linter/GlobalAttributeIn.lean", + "source_sha256": "8e21560794cc5b1bc2b80f60f47b5cfff6496eabda49abf7a0b5dfdbf82607cd", + "object_path": ".lake/build/lib/lean/Mathlib/Tactic/Linter/GlobalAttributeIn.olean", + "object_sha256": "15c9a28aa17049138cd70f12c60a1a33a579382d989bd6755f9c8b71056e4e31", + "object_bytes": 229728, + "imports": [ + "Init", + "Lean.Elab.Command", + "Mathlib.Tactic.Linter.Header" + ] + }, + { + "module": "Mathlib.Tactic.Linter.HashCommandLinter", + "root": "mathlib", + "source_path": "Mathlib/Tactic/Linter/HashCommandLinter.lean", + "source_sha256": "fdb198b5319feff34c6332e1b74eeef19ae5df6419820640b9cb6f1ac9e63a11", + "object_path": ".lake/build/lib/lean/Mathlib/Tactic/Linter/HashCommandLinter.olean", + "object_sha256": "5c8f2b9fe64db7fe5b6a36567827d07fcbf710a7c0cfec3c171a5a27dea3a3d5", + "object_bytes": 244280, + "imports": [ + "Init", + "Lean.Elab.Command", + "Mathlib.Tactic.Linter.Header" + ] + }, + { + "module": "Mathlib.Tactic.Linter.FlexibleLinter", + "root": "mathlib", + "source_path": "Mathlib/Tactic/Linter/FlexibleLinter.lean", + "source_sha256": "143dbb4720f80dab0ac8d691de0ec33315260931fee9ddd6f1d65abcb9dc5fde", + "object_path": ".lake/build/lib/lean/Mathlib/Tactic/Linter/FlexibleLinter.olean", + "object_sha256": "5c14c8b5184f96a8d4c6abcda75c5b34f4c3e2c106e32434098b655fafd5c3d0", + "object_bytes": 2718024, + "imports": [ + "Init", + "Lean.Elab.Command", + "Mathlib.Tactic.Linter.Header" + ] + }, + { + "module": "Batteries.Tactic.Lint.Basic", + "root": "mathlib", + "source_path": ".lake/packages/batteries/Batteries/Tactic/Lint/Basic.lean", + "source_sha256": "8b6819c283a43fd56debc191bac8b1d59ffc2ef2afbea2e0ce62bbf96358c734", + "object_path": ".lake/packages/batteries/.lake/build/lib/lean/Batteries/Tactic/Lint/Basic.olean", + "object_sha256": "3a6a102d376d8821e8e7eef82743f2736a878cb3227db26f973d30d1f19318c7", + "object_bytes": 635184, + "imports": [ + "Init", + "Lean.Structure", + "Lean.Elab.InfoTree.Main", + "Lean.Elab.Exception" + ] + }, + { + "module": "Batteries.Tactic.Lint.Misc", + "root": "mathlib", + "source_path": ".lake/packages/batteries/Batteries/Tactic/Lint/Misc.lean", + "source_sha256": "80e85be95b406a169f4599457a296bfef36709a122375732794d052dbe983200", + "object_path": ".lake/packages/batteries/.lake/build/lib/lean/Batteries/Tactic/Lint/Misc.olean", + "object_sha256": "e90fa3afa7058cf5f813fc5e21cfbbfe5bf1a70daaab8f8c06d4b1e3138cad7c", + "object_bytes": 916944, + "imports": [ + "Init", + "Lean.Util.CollectLevelParams", + "Lean.Util.ForEachExpr", + "Lean.Meta.ForEachExpr", + "Lean.Meta.GlobalInstances", + "Lean.Meta.Check", + "Lean.Util.Recognizers", + "Lean.DocString", + "Batteries.Tactic.Lint.Basic" + ] + }, + { + "module": "Batteries.Tactic.OpenPrivate", + "root": "mathlib", + "source_path": ".lake/packages/batteries/Batteries/Tactic/OpenPrivate.lean", + "source_sha256": "6d86873805769d8aeba4f4c79985f37a99f9bc29b25bd31b924689f1ae980ac6", + "object_path": ".lake/packages/batteries/.lake/build/lib/lean/Batteries/Tactic/OpenPrivate.olean", + "object_sha256": "783b9ab4f3bbd76d4450cc54cbee70ee247ebdd5aaf1787fe273479b36cb0bd7", + "object_bytes": 553832, + "imports": [ + "Init", + "Lean.Elab.Command", + "Lean.Util.FoldConsts", + "Lean.Parser.Module" + ] + }, + { + "module": "Batteries.Util.LibraryNote", + "root": "mathlib", + "source_path": ".lake/packages/batteries/Batteries/Util/LibraryNote.lean", + "source_sha256": "fc029a0e942a923588b6a424bf43d40cc34452ce71e83fba6d131457f3048682", + "object_path": ".lake/packages/batteries/.lake/build/lib/lean/Batteries/Util/LibraryNote.olean", + "object_sha256": "0664389a4614d85a2aac9f0678ebabf8d7282ea11630050a23ef86c2ed2127fc", + "object_bytes": 99808, + "imports": [ + "Init", + "Lean.Elab.Command" + ] + }, + { + "module": "Batteries.Tactic.Lint.Simp", + "root": "mathlib", + "source_path": ".lake/packages/batteries/Batteries/Tactic/Lint/Simp.lean", + "source_sha256": "deb8c429506e2b9fb21fe065d949d0962d296ef740fcdd665a8d270e5d5cef33", + "object_path": ".lake/packages/batteries/.lake/build/lib/lean/Batteries/Tactic/Lint/Simp.olean", + "object_sha256": "f52b204fd3a232a4e03cb843d2b29e72271a7f832b9137d3699d8eb56f62f281", + "object_bytes": 1045512, + "imports": [ + "Init", + "Lean.Meta.Tactic.Simp.Main", + "Batteries.Tactic.Lint.Basic", + "Batteries.Tactic.OpenPrivate", + "Batteries.Util.LibraryNote" + ] + }, + { + "module": "Batteries.Tactic.Lint.TypeClass", + "root": "mathlib", + "source_path": ".lake/packages/batteries/Batteries/Tactic/Lint/TypeClass.lean", + "source_sha256": "82466804c996c016b1924d3e74183aa4412a43cbcffef452d155a3e214f772c2", + "object_path": ".lake/packages/batteries/.lake/build/lib/lean/Batteries/Tactic/Lint/TypeClass.olean", + "object_sha256": "cf2d85b23708f7bd72451f02382bf08fa5a2342c781ecc69865193d44eefa62a", + "object_bytes": 208320, + "imports": [ + "Init", + "Lean.Meta.Instances", + "Batteries.Tactic.Lint.Basic" + ] + }, + { + "module": "Batteries.Tactic.Lint.Frontend", + "root": "mathlib", + "source_path": ".lake/packages/batteries/Batteries/Tactic/Lint/Frontend.lean", + "source_sha256": "a9fa9e3b6bf50d71bd8f3e50073d0c239d6146bc440431e8ed7bfde3e5d7ca97", + "object_path": ".lake/packages/batteries/.lake/build/lib/lean/Batteries/Tactic/Lint/Frontend.olean", + "object_sha256": "d13836772cdb372c9aae7fb69cb51feddbbc85779c9b80835a43950451874545", + "object_bytes": 1353520, + "imports": [ + "Init", + "Lean.Util.Paths", + "Lean.Elab.Command", + "Batteries.Tactic.Lint.Basic", + "Batteries.Tactic.OpenPrivate" + ] + }, + { + "module": "Batteries.Tactic.Lint", + "root": "mathlib", + "source_path": ".lake/packages/batteries/Batteries/Tactic/Lint.lean", + "source_sha256": "8e516f0a2e19d4b5404e14dfe86f1aba6a6a2881ddfc55ae8241b641d83f1cc8", + "object_path": ".lake/packages/batteries/.lake/build/lib/lean/Batteries/Tactic/Lint.olean", + "object_sha256": "5233546b1799c3b477f60d2dbfa0748f268647e778633c092615856977a10740", + "object_bytes": 20560, + "imports": [ + "Init", + "Batteries.Tactic.Lint.Misc", + "Batteries.Tactic.Lint.Simp", + "Batteries.Tactic.Lint.TypeClass", + "Batteries.Tactic.Lint.Frontend" + ] + }, + { + "module": "Mathlib.Tactic.DeclarationNames", + "root": "mathlib", + "source_path": "Mathlib/Tactic/DeclarationNames.lean", + "source_sha256": "a54cbc096c830706a1428fc0fc25b8d60aa9068c439266a788c516a402f222c2", + "object_path": ".lake/build/lib/lean/Mathlib/Tactic/DeclarationNames.olean", + "object_sha256": "888414faf5d978e3bd9cb310a3d9ae95d8d8e6a76dcea62c85836f50760ea8ba", + "object_bytes": 165160, + "imports": [ + "Init", + "Lean.DeclarationRange", + "Lean.ResolveName", + "Mathlib.Tactic.Linter.Header" + ] + }, + { + "module": "Mathlib.Tactic.Linter.Lint", + "root": "mathlib", + "source_path": "Mathlib/Tactic/Linter/Lint.lean", + "source_sha256": "2e3d501a572da84d75db9b5d51715b7a9e6688f2923db13dd14f67dfa8661f14", + "object_path": ".lake/build/lib/lean/Mathlib/Tactic/Linter/Lint.olean", + "object_sha256": "f2112010e8ca65cf93f1839be0b215a26390366a17bdf907c7b659844f9845bf", + "object_bytes": 287048, + "imports": [ + "Init", + "Batteries.Tactic.Lint", + "Mathlib.Tactic.DeclarationNames" + ] + }, + { + "module": "Mathlib.Tactic.Linter.Multigoal", + "root": "mathlib", + "source_path": "Mathlib/Tactic/Linter/Multigoal.lean", + "source_sha256": "c7aafaad3ce8bab2e54655ad349bb8c6e96cd60046c9bdaed173c077b0182990", + "object_path": ".lake/build/lib/lean/Mathlib/Tactic/Linter/Multigoal.olean", + "object_sha256": "86825de8b5c6c6a570be243fcc6e24ef82c8227b2ec34e5b055cbfd98e4b6b95", + "object_bytes": 624528, + "imports": [ + "Init", + "Lean.Elab.Command", + "Mathlib.Tactic.Linter.Header" + ] + }, + { + "module": "Mathlib.Tactic.Linter.OldObtain", + "root": "mathlib", + "source_path": "Mathlib/Tactic/Linter/OldObtain.lean", + "source_sha256": "03746fa8eefe9d454b63f69a264f11c3f015f5475215591db87d99f4fdbfac62", + "object_path": ".lake/build/lib/lean/Mathlib/Tactic/Linter/OldObtain.olean", + "object_sha256": "5b39546c058bc747b211085402a7a77ffcabb473f2d2dfed176e39d5e770a95d", + "object_bytes": 104344, + "imports": [ + "Init", + "Lean.Elab.Command", + "Mathlib.Tactic.Linter.Header" + ] + }, + { + "module": "Mathlib.Tactic.Linter.UnusedTacticExtension", + "root": "mathlib", + "source_path": "Mathlib/Tactic/Linter/UnusedTacticExtension.lean", + "source_sha256": "31a35fddda020203151f193ff016b9ab29bad2e9ad781b8a41e02989d806f016", + "object_path": ".lake/build/lib/lean/Mathlib/Tactic/Linter/UnusedTacticExtension.olean", + "object_sha256": "35e36db8d7e70b02d74afe0cfdda1ce76b4fe8705b5cf7243fee2fbfda08318f", + "object_bytes": 415616, + "imports": [ + "Init", + "Mathlib.Tactic.Linter.Header" + ] + }, + { + "module": "Batteries.Tactic.Unreachable", + "root": "mathlib", + "source_path": ".lake/packages/batteries/Batteries/Tactic/Unreachable.lean", + "source_sha256": "0e53b61434c837ca602167366c351fd6567289b1cc7eb0c0bfe2110b998c918e", + "object_path": ".lake/packages/batteries/.lake/build/lib/lean/Batteries/Tactic/Unreachable.olean", + "object_sha256": "eac74d421f4c4bd5e646abc7739820a4a67298af057270fbb97615b3c1790d5c", + "object_bytes": 104504, + "imports": [ + "Init", + "Lean.Elab.Tactic.Basic" + ] + }, + { + "module": "Mathlib.Tactic.Linter.UnusedTactic", + "root": "mathlib", + "source_path": "Mathlib/Tactic/Linter/UnusedTactic.lean", + "source_sha256": "5b8aa439f6ccead423110790b8feea18718d625d8e1c8123e0fa4a2e2d01b50a", + "object_path": ".lake/build/lib/lean/Mathlib/Tactic/Linter/UnusedTactic.olean", + "object_sha256": "6703b8028047cca9acfb3ed0ba879fff86dbf0efe0755b90bd9563669725f615", + "object_bytes": 781888, + "imports": [ + "Init", + "Lean.Parser.Syntax", + "Batteries.Tactic.Unreachable", + "Mathlib.Tactic.Linter.Header", + "Mathlib.Tactic.Linter.UnusedTacticExtension" + ] + }, + { + "module": "Mathlib.Tactic.Linter.Style", + "root": "mathlib", + "source_path": "Mathlib/Tactic/Linter/Style.lean", + "source_sha256": "55f5325512afb93d039485d646725edcc0bedd26866690470e7127508f0d67d2", + "object_path": ".lake/build/lib/lean/Mathlib/Tactic/Linter/Style.olean", + "object_sha256": "279f406416c3c1fcea9307a90635d913435df2125b27133d2837cc7606200495", + "object_bytes": 1201968, + "imports": [ + "Init", + "Lean.Elab.Command", + "Mathlib.Tactic.Linter.Header", + "Mathlib.Tactic.DeclarationNames" + ] + }, + { + "module": "Batteries.Data.NameSet", + "root": "mathlib", + "source_path": ".lake/packages/batteries/Batteries/Data/NameSet.lean", + "source_sha256": "4524af9fa26a307b7299d8d6d4baecddd4442fe168bb8abe5d9f4436f82a60d3", + "object_path": ".lake/packages/batteries/.lake/build/lib/lean/Batteries/Data/NameSet.olean", + "object_sha256": "6c3030ceccbf7813032d8ea318ace152636126564c763d5b4e2f14bc99dc8fc5", + "object_bytes": 80504, + "imports": [ + "Init", + "Lean.Data.NameMap" + ] + }, + { + "module": "ImportGraph.RequiredModules", + "root": "mathlib", + "source_path": ".lake/packages/importGraph/ImportGraph/RequiredModules.lean", + "source_sha256": "afd09f52b275aba6ab8f9a87f97581a36fdc641c78cdaa37f4e1227b78d28d10", + "object_path": ".lake/packages/importGraph/.lake/build/lib/lean/ImportGraph/RequiredModules.olean", + "object_sha256": "681d1f98d5c001c487d1f2c63f512bfc929a6245c4809ade31df857aba3e5983", + "object_bytes": 573160, + "imports": [ + "Init", + "Lean.CoreM", + "Lean.Data.NameMap", + "Lean.Environment", + "Lean.Util.FoldConsts", + "Batteries.Data.NameSet" + ] + }, + { + "module": "ImportGraph.Imports", + "root": "mathlib", + "source_path": ".lake/packages/importGraph/ImportGraph/Imports.lean", + "source_sha256": "db9e4e577ca63d6816ae49475cc3dcaaea899196c012d9a50e9804a2c800fc6e", + "object_path": ".lake/packages/importGraph/.lake/build/lib/lean/ImportGraph/Imports.olean", + "object_sha256": "e3344dc58a5d3e16d0466fa4e318b62700fbafcdd3965fea682d13521d3624f7", + "object_bytes": 868616, + "imports": [ + "Init", + "Lean.Elab.Command", + "Lean.Util.SearchPath", + "Lean.Server.GoTo", + "Lean.Widget.UserWidget", + "ImportGraph.RequiredModules" + ] + }, + { + "module": "Mathlib.Tactic.MinImports", + "root": "mathlib", + "source_path": "Mathlib/Tactic/MinImports.lean", + "source_sha256": "ff9cba6bef2d7a364f62087e3b994bb37bb38202f8740220b43d078c3a14eff4", + "object_path": ".lake/build/lib/lean/Mathlib/Tactic/MinImports.olean", + "object_sha256": "885dfe7be8742fbdef5469c7412a99ac091543c736843062d48930e8186bed58", + "object_bytes": 572624, + "imports": [ + "Init", + "Lean.Elab.DefView", + "Lean.Util.CollectAxioms", + "ImportGraph.Imports", + "ImportGraph.RequiredModules", + "Mathlib.Tactic.Linter.Header" + ] + }, + { + "module": "Mathlib.Init", + "root": "mathlib", + "source_path": "Mathlib/Init.lean", + "source_sha256": "3bf5cc3a77f343847f9d0844047b2628588316dd144ce52b3c2aa5fe30a1f276", + "object_path": ".lake/build/lib/lean/Mathlib/Init.olean", + "object_sha256": "d64336c1f02357495c223700d6d7f87aafb6fdceee95c29f36c648c41b30f312", + "object_bytes": 34528, + "imports": [ + "Init", + "Lean.Linter.Sets", + "Mathlib.Tactic.Linter.CommandStart", + "Mathlib.Tactic.Linter.DeprecatedSyntaxLinter", + "Mathlib.Tactic.Linter.DirectoryDependency", + "Mathlib.Tactic.Linter.DocPrime", + "Mathlib.Tactic.Linter.DocString", + "Mathlib.Tactic.Linter.GlobalAttributeIn", + "Mathlib.Tactic.Linter.HashCommandLinter", + "Mathlib.Tactic.Linter.Header", + "Mathlib.Tactic.Linter.FlexibleLinter", + "Mathlib.Tactic.Linter.Lint", + "Mathlib.Tactic.Linter.Multigoal", + "Mathlib.Tactic.Linter.OldObtain", + "Mathlib.Tactic.Linter.UnusedTacticExtension", + "Mathlib.Tactic.Linter.UnusedTactic", + "Mathlib.Tactic.Linter.Style", + "Mathlib.Tactic.MinImports" + ] + }, + { + "module": "Mathlib.Tactic.Lemma", + "root": "mathlib", + "source_path": "Mathlib/Tactic/Lemma.lean", + "source_sha256": "bf534e768b810014e26b13692b95540ed05f67a1a186b309b494c0cc3c2c1028", + "object_path": ".lake/build/lib/lean/Mathlib/Tactic/Lemma.olean", + "object_sha256": "db3a45be57bb4e02ce73aec7b6497830a79261d20d43f20f901ceeda8ecfa10f", + "object_bytes": 139744, + "imports": [ + "Init", + "Mathlib.Init", + "Lean.Parser.Command" + ] + }, + { + "module": "Mathlib.Tactic.TypeStar", + "root": "mathlib", + "source_path": "Mathlib/Tactic/TypeStar.lean", + "source_sha256": "fc04b05b5c9f1b28c72f184c7830661fee5e49efe3fb54e316f7dd6595bb3b73", + "object_path": ".lake/build/lib/lean/Mathlib/Tactic/TypeStar.olean", + "object_sha256": "e667e7ea74061d30a159d9c420f92f90aa51ec3bfd1dbd24b3d5e244946d42d5", + "object_bytes": 63232, + "imports": [ + "Init", + "Mathlib.Init", + "Lean.Elab.Term" + ] + }, + { + "module": "Mathlib.Data.Nat.Notation", + "root": "mathlib", + "source_path": "Mathlib/Data/Nat/Notation.lean", + "source_sha256": "a3bb71eaf2c7801aced62387277d449a400921e2925fdac97c60468596db3a6f", + "object_path": ".lake/build/lib/lean/Mathlib/Data/Nat/Notation.olean", + "object_sha256": "6c146647e8dd4f7459aaf542cfca666f9f2c727dee02909819627e60659d469c", + "object_bytes": 68400, + "imports": [ + "Init", + "Mathlib.Init" + ] + }, + { + "module": "Mathlib.Data.String.Defs", + "root": "mathlib", + "source_path": "Mathlib/Data/String/Defs.lean", + "source_sha256": "ff6a2fb50148787167a6906f329ca6be42e377178d10e7db63495159951ec364", + "object_path": ".lake/build/lib/lean/Mathlib/Data/String/Defs.olean", + "object_sha256": "962caedcfea59fe37575444d18a19daea71757ec81e1bd0cabef8cd8ab10b20e", + "object_bytes": 62192, + "imports": [ + "Init", + "Mathlib.Init" + ] + }, + { + "module": "Mathlib.Data.Array.Defs", + "root": "mathlib", + "source_path": "Mathlib/Data/Array/Defs.lean", + "source_sha256": "a28f8c99a8ac61b14f4467f353dce8578f518acd7524848d720177da3fd098ca", + "object_path": ".lake/build/lib/lean/Mathlib/Data/Array/Defs.olean", + "object_sha256": "e42e45cc32798b719b3813d17f2918b832e8bb2b69854af9917014c8797599a5", + "object_bytes": 78640, + "imports": [ + "Init", + "Mathlib.Init" + ] + }, + { + "module": "Mathlib.Util.MemoFix", + "root": "mathlib", + "source_path": "Mathlib/Util/MemoFix.lean", + "source_sha256": "751e97223ff3debe93374a035eb7e6a5b9d7d0f5aeedc4160695eaba8a89ada8", + "object_path": ".lake/build/lib/lean/Mathlib/Util/MemoFix.olean", + "object_sha256": "a9b64dd1c2cb8f279c5575ecd10b833ee210fb1a928b92b38e1487f19b96d594", + "object_bytes": 156048, + "imports": [ + "Init", + "Std.Data.HashMap.Basic", + "Mathlib.Init" + ] + }, + { + "module": "Mathlib.Lean.Expr.ReplaceRec", + "root": "mathlib", + "source_path": "Mathlib/Lean/Expr/ReplaceRec.lean", + "source_sha256": "6c9346d6ef1273dce155d237043b5defa332ec376032dc9a5ee25e21c50b0a2b", + "object_path": ".lake/build/lib/lean/Mathlib/Lean/Expr/ReplaceRec.olean", + "object_sha256": "097126f57751ffd6379bb863d3bc23c8882ad581f149e9f0003162856b6569ba", + "object_bytes": 66520, + "imports": [ + "Init", + "Lean.Expr", + "Mathlib.Util.MemoFix" + ] + }, + { + "module": "Mathlib.Lean.EnvExtension", + "root": "mathlib", + "source_path": "Mathlib/Lean/EnvExtension.lean", + "source_sha256": "c347317420bbd98480dbf7b888728dfa17a1f4036fbcceb0767679ef414ebf03", + "object_path": ".lake/build/lib/lean/Mathlib/Lean/EnvExtension.olean", + "object_sha256": "4d28c1ba7baf8046d5dd4fa712184bc26dcd4fcee1187342eaea8f1f138e6715", + "object_bytes": 27224, + "imports": [ + "Init", + "Mathlib.Init", + "Lean.ScopedEnvExtension" + ] + }, + { + "module": "Mathlib.Lean.Meta.Simp", + "root": "mathlib", + "source_path": "Mathlib/Lean/Meta/Simp.lean", + "source_sha256": "e029c67fea96a40450108f5bad27d5e1d1fdf7ed03027d4f4605f10b4eb0f088", + "object_path": ".lake/build/lib/lean/Mathlib/Lean/Meta/Simp.olean", + "object_sha256": "26e16a401bc86c4afcbcbfc14fd4d37be703c4316098d3ade94e634899c04e2c", + "object_bytes": 705600, + "imports": [ + "Init", + "Mathlib.Init", + "Lean.Elab.Tactic.Simp" + ] + }, + { + "module": "Mathlib.Lean.Name", + "root": "mathlib", + "source_path": "Mathlib/Lean/Name.lean", + "source_sha256": "461e2fb0440607120de24dda0e69a3994df20638f939fd985f150caa4f082261", + "object_path": ".lake/build/lib/lean/Mathlib/Lean/Name.olean", + "object_sha256": "67847f4dd59fc586c769219a71b74ddd9c1b1cc0d164c3c6131ffc68de8aebfd", + "object_bytes": 301000, + "imports": [ + "Init", + "Mathlib.Init", + "Lean.Meta.Match.MatcherInfo", + "Lean.Meta.Tactic.Delta", + "Std.Data.HashMap.Basic" + ] + }, + { + "module": "Batteries.Lean.NameMapAttribute", + "root": "mathlib", + "source_path": ".lake/packages/batteries/Batteries/Lean/NameMapAttribute.lean", + "source_sha256": "96528da8c2d72c1ed733e3b1b19cf5cf84fb89bac24383e0aa3c59ef12b80f5f", + "object_path": ".lake/packages/batteries/.lake/build/lib/lean/Batteries/Lean/NameMapAttribute.olean", + "object_sha256": "cd7882a33103d398f625ddd2ac504169cf37ce910dc1cabc04557438740af1b3", + "object_bytes": 230120, + "imports": [ + "Init", + "Lean.Attributes" + ] + }, + { + "module": "Batteries.CodeAction.Attr", + "root": "mathlib", + "source_path": ".lake/packages/batteries/Batteries/CodeAction/Attr.lean", + "source_sha256": "869f083f28aa547437b3f776f6d56ae099421bd8b25bf2f0aeada1995aa51dc2", + "object_path": ".lake/packages/batteries/.lake/build/lib/lean/Batteries/CodeAction/Attr.olean", + "object_sha256": "dae539df08fc7c18cb704e711ad1d7910c52e1c0901cb23825a6047813fc71ba", + "object_bytes": 446136, + "imports": [ + "Init", + "Lean.Server.CodeActions.Basic" + ] + }, + { + "module": "Batteries.CodeAction.Basic", + "root": "mathlib", + "source_path": ".lake/packages/batteries/Batteries/CodeAction/Basic.lean", + "source_sha256": "e8acdd34cf2c07bea581ab0f21af2d160cac91f2acb4c4e9c88790c390b2963b", + "object_path": ".lake/packages/batteries/.lake/build/lib/lean/Batteries/CodeAction/Basic.olean", + "object_sha256": "a0e78e50dd453bb77c0f37e1c84566eaa4e2346abc89ea983a320ed9f07d2fac", + "object_bytes": 313840, + "imports": [ + "Init", + "Lean.Elab.BuiltinTerm", + "Lean.Elab.BuiltinNotation", + "Lean.Server.InfoUtils", + "Lean.Server.CodeActions.Provider", + "Batteries.CodeAction.Attr" + ] + }, + { + "module": "Batteries.CodeAction.Deprecated", + "root": "mathlib", + "source_path": ".lake/packages/batteries/Batteries/CodeAction/Deprecated.lean", + "source_sha256": "0a1a645183475b8b834c77da7668522f88bd174f6e375b9fd1eeaa3ff4e28ae0", + "object_path": ".lake/packages/batteries/.lake/build/lib/lean/Batteries/CodeAction/Deprecated.olean", + "object_sha256": "8c27b35e1ae0635e3dbe730f3e32827923e9cb302a90609e3b3acb759d7d7fc2", + "object_bytes": 386552, + "imports": [ + "Init", + "Lean.Server.CodeActions", + "Batteries.CodeAction.Basic" + ] + }, + { + "module": "Batteries.Tactic.Alias", + "root": "mathlib", + "source_path": ".lake/packages/batteries/Batteries/Tactic/Alias.lean", + "source_sha256": "5f0972a53dd2d2261ab1289a91d2859eca1924271d85b6f7c139b302e344802b", + "object_path": ".lake/packages/batteries/.lake/build/lib/lean/Batteries/Tactic/Alias.olean", + "object_sha256": "d1b9b1c9ddf5d99994b963ef95e2877e800dcf14d9d8f7b625c51bfe836748f4", + "object_bytes": 937616, + "imports": [ + "Init", + "Lean.Elab.Command", + "Lean.Elab.DeclarationRange", + "Lean.Compiler.NoncomputableAttr", + "Lean.DocString", + "Batteries.CodeAction.Deprecated" + ] + }, + { + "module": "Batteries.Tactic.Trans", + "root": "mathlib", + "source_path": ".lake/packages/batteries/Batteries/Tactic/Trans.lean", + "source_sha256": "6cfd19c9cc734ede3e1be7b336ecb387c96a784deabb4bfb4e37c580ec0d01b6", + "object_path": ".lake/packages/batteries/.lake/build/lib/lean/Batteries/Tactic/Trans.olean", + "object_sha256": "02f2c17b30defaaf0d2ff222a95d12f5a1fbbdf94f105ef97c6ac728a0639aa2", + "object_bytes": 1497192, + "imports": [ + "Init", + "Lean.Elab.Tactic.ElabTerm", + "Batteries.Tactic.Alias" + ] + }, + { + "module": "Mathlib.Tactic.Eqns", + "root": "mathlib", + "source_path": "Mathlib/Tactic/Eqns.lean", + "source_sha256": "24c5e4c3bd84ef97855c8845e13c49cf404ca01d37002f54aa40848cbb995f56", + "object_path": ".lake/build/lib/lean/Mathlib/Tactic/Eqns.olean", + "object_sha256": "a9785b45ff2efbf6eef160de48f70c9a3958b9d0ddd2bdfba33329dd0c2be698", + "object_bytes": 120992, + "imports": [ + "Init", + "Mathlib.Init", + "Lean.Meta.Eqns", + "Batteries.Lean.NameMapAttribute", + "Lean.Elab.Exception", + "Lean.Elab.InfoTree.Main" + ] + }, + { + "module": "Mathlib.Tactic.Simps.NotationClass", + "root": "mathlib", + "source_path": "Mathlib/Tactic/Simps/NotationClass.lean", + "source_sha256": "046b6dc77f1d9b2526a453585bf7ee4e6f847d9742c7e057b9f1e3d7b5591157", + "object_path": ".lake/build/lib/lean/Mathlib/Tactic/Simps/NotationClass.olean", + "object_sha256": "4fdec3f68cd03c474ffd56c4cee5ffbafaa1d7f48dfe5fa3168196c3751faec2", + "object_bytes": 437208, + "imports": [ + "Init", + "Mathlib.Init", + "Lean.Elab.Exception", + "Batteries.Lean.NameMapAttribute", + "Batteries.Tactic.Lint" + ] + }, + { + "module": "Mathlib.Lean.Expr.Basic", + "root": "mathlib", + "source_path": "Mathlib/Lean/Expr/Basic.lean", + "source_sha256": "a8aa0f71dfed9ee59bdc5a53ca41b68c7abadbc6979e6d6d2cc1992375185523", + "object_path": ".lake/build/lib/lean/Mathlib/Lean/Expr/Basic.olean", + "object_sha256": "758c988fedc444846bbbfdb977b5d1ef8cae41416dd2e6ff0649b26bde8bdabd", + "object_bytes": 1329728, + "imports": [ + "Init", + "Mathlib.Init", + "Lean.Meta.Tactic.Rewrite", + "Batteries.Tactic.Alias", + "Lean.Elab.Binders" + ] + }, + { + "module": "Mathlib.Tactic.Simps.Basic", + "root": "mathlib", + "source_path": "Mathlib/Tactic/Simps/Basic.lean", + "source_sha256": "5dc9958f2b37b1c8f36b7d968fbbc202c70e5ef526d1bd890d0665b700434214", + "object_path": ".lake/build/lib/lean/Mathlib/Tactic/Simps/Basic.olean", + "object_sha256": "0f567dea7b201b9942efbe1baff81cf83e20c706e4f9b4434bc0cc48b52cdee1", + "object_bytes": 4075624, + "imports": [ + "Init", + "Lean.Elab.Tactic.Simp", + "Lean.Elab.App", + "Mathlib.Tactic.Simps.NotationClass", + "Mathlib.Lean.Expr.Basic" + ] + }, + { + "module": "Mathlib.Tactic.ToAdditive.Frontend", + "root": "mathlib", + "source_path": "Mathlib/Tactic/ToAdditive/Frontend.lean", + "source_sha256": "15e721abb292f828e615807ecbd75414ceb0b36dcc25cc3deead464859cc2826", + "object_path": ".lake/build/lib/lean/Mathlib/Tactic/ToAdditive/Frontend.olean", + "object_sha256": "354bcb84d3e820999db2f5b4ed293dc4135763eaa4523b574f8a18cb647b610b", + "object_bytes": 5117880, + "imports": [ + "Init", + "Mathlib.Data.Nat.Notation", + "Mathlib.Data.String.Defs", + "Mathlib.Data.Array.Defs", + "Mathlib.Lean.Expr.ReplaceRec", + "Mathlib.Lean.EnvExtension", + "Mathlib.Lean.Meta.Simp", + "Mathlib.Lean.Name", + "Lean.Elab.Tactic.Ext", + "Lean.Meta.Tactic.Symm", + "Lean.Meta.Tactic.Rfl", + "Lean.Meta.Match.MatcherInfo", + "Lean.Meta.AbstractNestedProofs", + "Batteries.Lean.NameMapAttribute", + "Batteries.Tactic.Lint", + "Batteries.Tactic.Trans", + "Mathlib.Tactic.Eqns", + "Mathlib.Tactic.Simps.Basic" + ] + }, + { + "module": "Mathlib.Tactic.ToAdditive", + "root": "mathlib", + "source_path": "Mathlib/Tactic/ToAdditive.lean", + "source_sha256": "c8eb34996949306a2a75e7d4d8ba97f3bf633ed4393e4e24f6a1669cd905f84c", + "object_path": ".lake/build/lib/lean/Mathlib/Tactic/ToAdditive.olean", + "object_sha256": "7452197d9f2d79ca811c6c55e6e57cc789d6bb43dc6ab975fbc2cedd82494f67", + "object_bytes": 30520, + "imports": [ + "Init", + "Mathlib.Tactic.ToAdditive.Frontend" + ] + }, + { + "module": "Mathlib.Util.AssertExistsExt", + "root": "mathlib", + "source_path": "Mathlib/Util/AssertExistsExt.lean", + "source_sha256": "ded44b58b2ff9fba16057593cb92ed0f4a8b2e17db640607b0ad22772f563ae4", + "object_path": ".lake/build/lib/lean/Mathlib/Util/AssertExistsExt.olean", + "object_sha256": "0227926185e7dbc18b9b3a9129db847e0cbb19409325bd9da5193c825fcb96b4", + "object_bytes": 266344, + "imports": [ + "Init", + "Lean.Environment", + "Mathlib.Init" + ] + }, + { + "module": "Mathlib.Util.AssertExists", + "root": "mathlib", + "source_path": "Mathlib/Util/AssertExists.lean", + "source_sha256": "1f5257ff086e8a752ea2444799e6c50620cde5d7bf5d63166a2eaf3c98ab0a0e", + "object_path": ".lake/build/lib/lean/Mathlib/Util/AssertExists.olean", + "object_sha256": "47eeca8b893605430271a023fc1a32203ed700d551da8110ad7a93bc09f3068f", + "object_bytes": 328632, + "imports": [ + "Init", + "Mathlib.Init", + "Lean.Elab.Command", + "Mathlib.Util.AssertExistsExt" + ] + }, + { + "module": "Mathlib.Algebra.Notation.Defs", + "root": "mathlib", + "source_path": "Mathlib/Algebra/Notation/Defs.lean", + "source_sha256": "003125924acc88f5764746a79dbdf37ba7d05bd98d9d7615978439283a47a161", + "object_path": ".lake/build/lib/lean/Mathlib/Algebra/Notation/Defs.olean", + "object_sha256": "4df9625902c6de0cbafa162767b1f0d6e2ca0268b5019cf1fb34068d1bf3959b", + "object_bytes": 300072, + "imports": [ + "Init", + "Mathlib.Tactic.Lemma", + "Mathlib.Tactic.TypeStar", + "Mathlib.Tactic.ToAdditive", + "Mathlib.Util.AssertExists" + ] + }, + { + "module": "Mathlib.Data.Int.Notation", + "root": "mathlib", + "source_path": "Mathlib/Data/Int/Notation.lean", + "source_sha256": "0ce97b89f29a3aeec02fe226143a07af2ca8e0f9155fef23189e5e43f474e17f", + "object_path": ".lake/build/lib/lean/Mathlib/Data/Int/Notation.olean", + "object_sha256": "ae4ed20d22119a3821dcbb3582dcab145b0cded88e4edc0f78433b76a36b71c9", + "object_bytes": 68648, + "imports": [ + "Init", + "Mathlib.Init" + ] + }, + { + "module": "Mathlib.Data.Nat.BinaryRec", + "root": "mathlib", + "source_path": "Mathlib/Data/Nat/BinaryRec.lean", + "source_sha256": "8b30dcfef17485546950683e6e8e8134fdb2de4bac807a88a9b7fa03b462bec4", + "object_path": ".lake/build/lib/lean/Mathlib/Data/Nat/BinaryRec.olean", + "object_sha256": "e7af56e852da2e353d8171a07ab946f167114f67b7de46c7e4116f0fad86cd4b", + "object_bytes": 222352, + "imports": [ + "Init", + "Batteries.Tactic.Alias", + "Mathlib.Init" + ] + }, + { + "module": "Mathlib.Tactic.AdaptationNote", + "root": "mathlib", + "source_path": "Mathlib/Tactic/AdaptationNote.lean", + "source_sha256": "6a17a34456bc086953d7b7eae7d8efe8e347674cb2a4b1e931f5b1403d3cee98", + "object_path": ".lake/build/lib/lean/Mathlib/Tactic/AdaptationNote.olean", + "object_sha256": "eb844ea3268b74c0bfa59029f7c3b40333062356ee60894ac041361eb623ef68", + "object_bytes": 198800, + "imports": [ + "Init", + "Mathlib.Init", + "Lean.Meta.Tactic.TryThis" + ] + }, + { + "module": "Mathlib.Tactic.Attr.Register", + "root": "mathlib", + "source_path": "Mathlib/Tactic/Attr/Register.lean", + "source_sha256": "481191717f0be1d3c826f1720473aab95367e1234340d3d8e279826575ddebcd", + "object_path": ".lake/build/lib/lean/Mathlib/Tactic/Attr/Register.olean", + "object_sha256": "6c30b931a9786b5c65a51913398f2e13c7c81563601ba7c36b1a4139e057f965", + "object_bytes": 320904, + "imports": [ + "Init", + "Mathlib.Init", + "Lean.Meta.Tactic.Simp.SimpTheorems", + "Lean.Meta.Tactic.Simp.RegisterCommand", + "Lean.LabelAttribute" + ] + }, + { + "module": "Batteries.Logic", + "root": "mathlib", + "source_path": ".lake/packages/batteries/Batteries/Logic.lean", + "source_sha256": "f3a60d5481fa3fbc40cc98bd4aa409881c9f23f6b2470b993ef1ab208cd0e7d8", + "object_path": ".lake/packages/batteries/.lake/build/lib/lean/Batteries/Logic.olean", + "object_sha256": "f3fb9a4516f644dbe2b0a31e1e9efa0986c148682a980baad558cdfad1aab1a5", + "object_bytes": 124880, + "imports": [ + "Init", + "Batteries.Tactic.Alias" + ] + }, + { + "module": "Mathlib.Logic.Function.Defs", + "root": "mathlib", + "source_path": "Mathlib/Logic/Function/Defs.lean", + "source_sha256": "cb7338e10d5910b2c32d29b2fa0a2b6dc50e0fb8716db8c1d269c9c017394848", + "object_path": ".lake/build/lib/lean/Mathlib/Logic/Function/Defs.olean", + "object_sha256": "a01fc9a5fcf8d1f09fc81f2b5f137196b413862ca0c0ac45ab2c991b7aef907c", + "object_bytes": 218120, + "imports": [ + "Init", + "Mathlib.Tactic.AdaptationNote", + "Mathlib.Tactic.Attr.Register", + "Mathlib.Tactic.Lemma", + "Mathlib.Tactic.Eqns", + "Mathlib.Tactic.TypeStar", + "Batteries.Logic" + ] + }, + { + "module": "Mathlib.Tactic.OfNat", + "root": "mathlib", + "source_path": "Mathlib/Tactic/OfNat.lean", + "source_sha256": "11f61c2bcf2f9a9ad9631c787a1d6e9f5fa3681cd88944baae3df688b7eb65c4", + "object_path": ".lake/build/lib/lean/Mathlib/Tactic/OfNat.olean", + "object_sha256": "d27b7644d28015181a1431109221dea6bed81fb95d2dddfc625b86c30ade6a7d", + "object_bytes": 78968, + "imports": [ + "Init", + "Mathlib.Init" + ] + }, + { + "module": "Mathlib.Algebra.Group.Defs", + "root": "mathlib", + "source_path": "Mathlib/Algebra/Group/Defs.lean", + "source_sha256": "60e2cfa6b828d521d3c0362d0f52e45db6c3fca8b308a6fe2aea5ef298faa330", + "object_path": ".lake/build/lib/lean/Mathlib/Algebra/Group/Defs.olean", + "object_sha256": "729539397d6bfe4019e19cc185b09c60b6673ae88e027ae0cca725b6723aa23a", + "object_bytes": 2399704, + "imports": [ + "Init", + "Mathlib.Algebra.Notation.Defs", + "Mathlib.Data.Int.Notation", + "Mathlib.Data.Nat.BinaryRec", + "Mathlib.Logic.Function.Defs", + "Mathlib.Tactic.Simps.Basic", + "Mathlib.Tactic.OfNat", + "Batteries.Logic" + ] + }, + { + "module": "Mathlib.Algebra.Group.Nat.Defs", + "root": "mathlib", + "source_path": "Mathlib/Algebra/Group/Nat/Defs.lean", + "source_sha256": "fea990400ac91b2bdfb07b4e0a6c5ca42d568c79ba1449a94acd96aa35d18922", + "object_path": ".lake/build/lib/lean/Mathlib/Algebra/Group/Nat/Defs.olean", + "object_sha256": "9b04c6231f62059619dd9dbc7a3f5a2f745f707d701dec9308d4d26d87f14380", + "object_bytes": 70328, + "imports": [ + "Init", + "Mathlib.Algebra.Group.Defs" + ] + }, + { + "module": "Mathlib.Tactic.Core", + "root": "mathlib", + "source_path": "Mathlib/Tactic/Core.lean", + "source_sha256": "8e8a11b3c417b97b3018f28d70607b99347d5626d15ea0b6c42e1695b9bc7f44", + "object_path": ".lake/build/lib/lean/Mathlib/Tactic/Core.olean", + "object_sha256": "b193105c3fdd5c073d1504d75f632201fb8bb8194080c5837e5494440dbae531", + "object_bytes": 675552, + "imports": [ + "Init", + "Lean.Elab.PreDefinition.Basic", + "Lean.Elab.Tactic.ElabTerm", + "Lean.Util.Paths", + "Lean.Meta.Tactic.Intro", + "Mathlib.Lean.Expr.Basic", + "Batteries.Tactic.OpenPrivate" + ] + }, + { + "module": "Mathlib.Tactic.SplitIfs", + "root": "mathlib", + "source_path": "Mathlib/Tactic/SplitIfs.lean", + "source_sha256": "bc0bf5bfa1998930a3a27e6abf4304a5a71296cbd106c80a90fa49c087fb4449", + "object_path": ".lake/build/lib/lean/Mathlib/Tactic/SplitIfs.olean", + "object_sha256": "bb3a34cdf2a4a8cdbe7096beb5916c0bf07c1e1dd99165656a87bbdfe4d1c503", + "object_bytes": 634976, + "imports": [ + "Init", + "Lean.Elab.Tactic.Location", + "Lean.Meta.Tactic.SplitIf", + "Lean.Elab.Tactic.Simp", + "Mathlib.Tactic.Core" + ] + } + ], + "core_module_count": 1300, + "noncore_module_count": 66, + "noncore_object_bytes": 40550808, + "downloads": false +} diff --git a/research/lean-count-receipt-amortization/LICENSE b/research/lean-count-receipt-amortization/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/lean-count-receipt-amortization/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/research/lean-count-receipt-amortization/MANIFEST.json b/research/lean-count-receipt-amortization/MANIFEST.json new file mode 100644 index 0000000000..61ff3f5115 --- /dev/null +++ b/research/lean-count-receipt-amortization/MANIFEST.json @@ -0,0 +1,685 @@ +{ + "format": "bounded-lean-count-receipt-amortization-v1", + "lean_version": "4.21.0", + "source_modules": 12, + "included_source_modules": 3, + "external_source_modules": 9, + "source_bytes": 91019, + "included_source_bytes": 16879, + "compile_order": [ + { + "module": "IntegerConvolution", + "file": "Lean/IntegerConvolution.lean", + "origin": "pr488", + "sha256": "0bc86f2fa8e68f39df77be603d2a9634bc008745093286903105378ab45938ea", + "bytes": 2055, + "imports": [ + "Lean" + ], + "expected_probes": [ + { + "declaration": "CurrentMain.IntegerConvolution.value_addCoefficients", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CurrentMain.IntegerConvolution.value_map_mul", + "axioms": [ + "propext" + ] + }, + { + "declaration": "CurrentMain.IntegerConvolution.convolution_value", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CurrentMain.IntegerConvolution.binary_convolution", + "axioms": [ + "propext", + "Quot.sound" + ] + } + ] + }, + { + "module": "FixedTapeMachine", + "file": "Lean/FixedTapeMachine.lean", + "origin": "pr488", + "sha256": "92dadedc9f6e23d12633549b53ca8f917360e4fedac0b64a58d18feea741a5ed", + "bytes": 4523, + "imports": [ + "IntegerConvolution" + ], + "expected_probes": [ + { + "declaration": "CurrentMain.FixedTapeMachine.initial_inputA", + "axioms": [ + "propext" + ] + }, + { + "declaration": "CurrentMain.FixedTapeMachine.initial_inputB", + "axioms": [ + "propext" + ] + }, + { + "declaration": "CurrentMain.FixedTapeMachine.initial_output", + "axioms": [ + "propext" + ] + }, + { + "declaration": "CurrentMain.FixedTapeMachine.run_halted", + "axioms": [] + }, + { + "declaration": "CurrentMain.FixedTapeMachine.run_add", + "axioms": [ + "propext" + ] + } + ] + }, + { + "module": "CarryTape", + "file": "CarryTape.lean", + "origin": "pr511", + "sha256": "20d13d9d2da74452e45c0a175b643556615ba14187bf8fb0e4393e44842c17a5", + "bytes": 8348, + "imports": [ + "Lean" + ], + "expected_probes": [ + { + "declaration": "CurrentMain.CarryTape.run_add", + "axioms": [ + "propext" + ] + }, + { + "declaration": "CurrentMain.CarryTape.carry_execution", + "axioms": [ + "propext" + ] + }, + { + "declaration": "CurrentMain.CarryTape.rewind_execution", + "axioms": [ + "propext" + ] + }, + { + "declaration": "CurrentMain.CarryTape.carryFinish_rewind", + "axioms": [ + "propext" + ] + }, + { + "declaration": "CurrentMain.CarryTape.increment_execution", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CurrentMain.CarryTape.increment_length", + "axioms": [ + "propext" + ] + }, + { + "declaration": "CurrentMain.CarryTape.all_ones_execution", + "axioms": [ + "propext", + "Quot.sound" + ] + } + ] + }, + { + "module": "CarryTapePass", + "file": "CarryTapePass.lean", + "origin": "pr511", + "sha256": "680b5d16736880ac6a02f27e9503e1cc01479bb2b35bb7546d9108dcb4b4ef2b", + "bytes": 5662, + "imports": [ + "CarryTape" + ], + "expected_probes": [ + { + "declaration": "CurrentMain.CarryTape.value_bound", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CurrentMain.CarryTape.increment_value", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CurrentMain.CarryTape.increment_mod", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CurrentMain.CarryTape.pass_length", + "axioms": [ + "propext" + ] + }, + { + "declaration": "CurrentMain.CarryTape.pass_value", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CurrentMain.CarryTape.pass_even", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CurrentMain.CarryTape.empty_pass_one", + "axioms": [] + }, + { + "declaration": "CurrentMain.CarryTape.complete_pass", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CurrentMain.CarryTape.incrementReceipt_realized", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CurrentMain.CarryTape.pass_successor_realized", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CurrentMain.CarryTape.full_pass24_index_traffic", + "axioms": [ + "propext", + "Quot.sound" + ] + } + ] + }, + { + "module": "BinaryCarryIncrement", + "file": "BinaryCarryIncrement.lean", + "origin": "pr511", + "sha256": "b0f639159e2169c75e6d7a13663adee5107648a32b7ff9203f92792e31012dce", + "bytes": 9032, + "imports": [ + "FixedTapeMachine", + "CarryTapePass" + ], + "expected_probes": [ + { + "declaration": "CurrentMain.BinaryCarryIncrement.increment_run", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CurrentMain.BinaryCarryIncrement.final_halted", + "axioms": [ + "propext" + ] + }, + { + "declaration": "CurrentMain.BinaryCarryIncrement.increment_length", + "axioms": [ + "propext" + ] + }, + { + "declaration": "CurrentMain.BinaryCarryIncrement.value_binding", + "axioms": [] + }, + { + "declaration": "CurrentMain.BinaryCarryIncrement.increment_modular_value", + "axioms": [ + "propext", + "Quot.sound" + ] + } + ] + }, + { + "module": "BinaryCountDispatcher", + "file": "BinaryCountDispatcher.lean", + "origin": "pr511", + "sha256": "ec24af9483d59ce3248802378218d4b478490aa2458e136880f36e7f49356e93", + "bytes": 14544, + "imports": [ + "BinaryCarryIncrement" + ], + "expected_probes": [ + { + "declaration": "CurrentMain.BinaryCountDispatcher.count_run", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CurrentMain.BinaryCountDispatcher.final_halted", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CurrentMain.BinaryCountDispatcher.counter_length", + "axioms": [ + "propext" + ] + }, + { + "declaration": "CurrentMain.BinaryCountDispatcher.counter_value", + "axioms": [ + "propext", + "Quot.sound" + ] + } + ] + }, + { + "module": "BinaryCountDispatcherMarkedInput", + "file": "BinaryCountDispatcherMarkedInput.lean", + "origin": "pr519", + "sha256": "b7f0cecb69194b8d851037e8321e245dc383c62e3e2475c9d4508d29390191cc", + "bytes": 10257, + "imports": [ + "BinaryCountDispatcher" + ], + "expected_probes": [ + { + "declaration": "CurrentMain.BinaryCountDispatcherMarkedInput.count_run", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CurrentMain.BinaryCountDispatcherMarkedInput.final_halted", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CurrentMain.BinaryCountDispatcherMarkedInput.counter_length", + "axioms": [ + "propext" + ] + }, + { + "declaration": "CurrentMain.BinaryCountDispatcherMarkedInput.counter_value", + "axioms": [ + "propext", + "Quot.sound" + ] + } + ] + }, + { + "module": "BinaryCounterZeroAllocation", + "file": "BinaryCounterZeroAllocation.lean", + "origin": "pr519", + "sha256": "5cf3fdfcd6c6a6cefa89b9a83dc678b6f40d9a608c318334ae92a66d25ea7477", + "bytes": 9595, + "imports": [ + "BinaryCountDispatcherMarkedInput" + ], + "expected_probes": [ + { + "declaration": "CurrentMain.BinaryCounterZeroAllocation.allocate_run_exact", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CurrentMain.BinaryCounterZeroAllocation.final_halted", + "axioms": [ + "propext" + ] + }, + { + "declaration": "CurrentMain.BinaryCounterZeroAllocation.allocated_width", + "axioms": [ + "propext" + ] + } + ] + }, + { + "module": "BinaryAutomaticWidthCount", + "file": "BinaryAutomaticWidthCount.lean", + "origin": "pr519", + "sha256": "5dcf4ec74f08d9662738db413d144e16f4b555e56f29e0846ad5c88726420154", + "bytes": 10124, + "imports": [ + "BinaryCounterZeroAllocation" + ], + "expected_probes": [ + { + "declaration": "CurrentMain.BinaryAutomaticWidthCount.count_run", + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ] + }, + { + "declaration": "CurrentMain.BinaryAutomaticWidthCount.final_halted", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CurrentMain.BinaryAutomaticWidthCount.final_input", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CurrentMain.BinaryAutomaticWidthCount.final_counter", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CurrentMain.BinaryAutomaticWidthCount.counter_width", + "axioms": [ + "propext" + ] + }, + { + "declaration": "CurrentMain.BinaryAutomaticWidthCount.counter_value", + "axioms": [ + "propext", + "Quot.sound" + ] + } + ] + }, + { + "module": "RippleCounterListData", + "file": "RippleCounterListData.lean", + "origin": "package", + "sha256": "6ad007faa04e8f22895489011f48c6574dca4a31809f3456fbcf5bea4a5bb302", + "bytes": 1005, + "imports": [ + "Lean", + "Mathlib.Algebra.Group.Nat.Defs", + "Mathlib.Tactic.SplitIfs" + ], + "accepted_research_source_sha256": "6ad007faa04e8f22895489011f48c6574dca4a31809f3456fbcf5bea4a5bb302", + "public_comment_only_transition": false, + "expected_probes": [] + }, + { + "module": "CounterArithmeticPure", + "file": "CounterArithmeticPure.lean", + "origin": "package", + "sha256": "7fea5026e56a66f10bcda803c1c8b6f5b3745f029840cc09eb4f6fa197990e0b", + "bytes": 11111, + "imports": [ + "RippleCounterListData" + ], + "accepted_research_source_sha256": "1ad26524cc5932842e8f233aa3b8b4f9c0ecb12a4ab06478c6c6f0c42827144b", + "public_comment_only_transition": true, + "expected_probes": [ + { + "declaration": "CounterArithmetic.updated_nil", + "axioms": [] + }, + { + "declaration": "CounterArithmetic.updated_carry", + "axioms": [ + "propext" + ] + }, + { + "declaration": "CounterArithmetic.updated_stop", + "axioms": [ + "propext" + ] + }, + { + "declaration": "CounterArithmetic.updated_length", + "axioms": [ + "propext" + ] + }, + { + "declaration": "CounterArithmetic.carryLength_le_length", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CounterArithmetic.potential_le_length", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CounterArithmetic.potential_accounting", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CounterArithmetic.amortized_step", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CounterArithmetic.iterate_length", + "axioms": [ + "propext" + ] + }, + { + "declaration": "CounterArithmetic.amortized_total", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CounterArithmetic.total_steps_bound", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CounterArithmetic.value_bound", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CounterArithmetic.increment_value", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CounterArithmetic.decrement_value", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CounterArithmetic.decrement_underflow_iff_zero", + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ] + }, + { + "declaration": "CounterArithmetic.overflow_updated", + "axioms": [ + "propext" + ] + }, + { + "declaration": "CounterArithmetic.zero_replicate_value", + "axioms": [ + "propext" + ] + }, + { + "declaration": "CounterArithmetic.increment_overflow_iff_max", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CounterArithmetic.decrement_positive", + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ] + }, + { + "declaration": "CounterArithmetic.countdown_value", + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ] + }, + { + "declaration": "CounterArithmetic.countdown_not_finished", + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ] + }, + { + "declaration": "CounterArithmetic.countdown_final_underflow", + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ] + }, + { + "declaration": "CounterArithmetic.complete_block_cost", + "axioms": [ + "propext", + "Quot.sound" + ] + } + ] + }, + { + "module": "BinaryCountReceiptAmortization", + "file": "BinaryCountReceiptAmortization.lean", + "origin": "package", + "sha256": "48f51cf3387fbcd88c75f05bd7714716be33b5590f976a3519fa025ea64bba08", + "bytes": 4763, + "imports": [ + "CounterArithmeticPure", + "BinaryAutomaticWidthCount" + ], + "accepted_research_source_sha256": "48f51cf3387fbcd88c75f05bd7714716be33b5590f976a3519fa025ea64bba08", + "public_comment_only_transition": false, + "expected_probes": [ + { + "declaration": "CurrentMain.BinaryCountReceiptAmortization.prefix_binding", + "axioms": [ + "propext" + ] + }, + { + "declaration": "CurrentMain.BinaryCountReceiptAmortization.increment_binding", + "axioms": [ + "propext" + ] + }, + { + "declaration": "CurrentMain.BinaryCountReceiptAmortization.increment_reads_binding", + "axioms": [ + "propext" + ] + }, + { + "declaration": "CurrentMain.BinaryCountReceiptAmortization.pass_result_binding", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CurrentMain.BinaryCountReceiptAmortization.pass_reads_binding", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CurrentMain.BinaryCountReceiptAmortization.pass_reads_le", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CurrentMain.BinaryCountReceiptAmortization.count_run_linear", + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ] + } + ] + } + ] +} diff --git a/research/lean-count-receipt-amortization/NOTICE b/research/lean-count-receipt-amortization/NOTICE new file mode 100644 index 0000000000..59d8e0cf31 --- /dev/null +++ b/research/lean-count-receipt-amortization/NOTICE @@ -0,0 +1,415 @@ +A sharper exponent for integer multiplication +Copyright 2026 Douglas Colkitt + +This project includes unmodified source files from OpenAI's manuscript +"Integer multiplication below n log n" and its accompanying repository: +https://github.com/openai/math +Commit: adc7f1241b42e322a6451854ab7e4b4c146bf78a + +The original manuscript identifies OpenAI as its author. Its Apache-2.0 +license is retained at upstream/LICENSE. The exact source URLs and hashes +are recorded in upstream/manifest.json. Proposed modifications are supplied +as separate files under patches/; upstream source files remain unchanged. + +The original local research note, scripts, certificates, patches, and +documentation were prepared by Douglas Colkitt with assistance from OpenAI +Codex. The community release incorporates work by the contributors identified +in the notices below; it is not solely Douglas Colkitt's work. +This project is not an official OpenAI release or an OpenAI endorsement. + +Related contributions (not imported in this checkpoint): +Zhihao Chen (jacklightChen), PR #7, supplied an earlier ternary five-subset +motif, finite-alphabet transfer and a different compressed producer: +https://github.com/CrocSwap/integer-mult-bounds/pull/7 +The present checkpoint claims no priority for that motif. Related compressed +complex-network work was submitted by eumemic in PR #3: +https://github.com/CrocSwap/integer-mult-bounds/pull/3 +The pending contributions and their stronger bounds require their own review; +this notice does not represent adoption or verification of their claims. + +Additional community work, including parallel and superseded submissions, is +acknowledged in CONTRIBUTORS.md, with pinned submission metadata in +docs/research/contribution-snapshot.json. These acknowledgements do not imply +joint authorship of the checkpoint, incorporation of pending code, or verification +of submitted mathematical claims. Original source-specific notices remain in force. + +Community release (accepted by conditional maintainer audit): +The following original contributor notices apply to the imported PR #39 chain. +The preceding non-import statements describe the preserved 2^-30 checkpoint. + +Ternary five-subset construction and common-four-point resynthesis +Copyright 2026 Zhihao Chen (jacklightChen) + +This is Zhihao Chen's first submission of this specific construction to this +repository. Research, proof development, code and verification were prepared +with substantial assistance from GPT-6 Astra (OpenAI Codex), as identified by +the contributor. This is not independent review or an OpenAI endorsement. +Future research building on this contribution should explicitly acknowledge +Zhihao Chen (jacklightChen), cite the accompanying note and pull request, and +retain the preceding contributors' attribution. This notice records research +provenance; the repository's Apache-2.0 license remains unchanged. + +Dependencies retained from eumemic's Claude-assisted PRs #3 and #5: +https://github.com/CrocSwap/integer-mult-bounds/pull/3 +https://github.com/CrocSwap/integer-mult-bounds/pull/5 +PR #5 commit: d3d370c34937503bd3fa63c83d505a05e8e50893 +These include complex_circuit.py, complex_network.py, fast_gaussian.py, +their generators, construction notes and certificates. The Gaussian input +scaling proof is corrected in this derivative; see the modification notice below. +Aligned pairing also appears in Bortlesboat's PR #2. Retained totals and bank +sharing appear in dleen's PR #4 and cheaper retained centers in eumemic's PR #6. +Their results and ideas are credited separately from this new construction. + +Bulk recursion and controlled tensor basis, 8 October 2026 +Copyright 2026 icekylinx + +The new projector batching, controlled simultaneous basis, mixed-width tape +recursions, whole-residual complex recursion, and dependency-path precision +guard in the batched-23 proof package are contributed by icekylinx, developed +with substantial OpenAI GPT-6 Astra assistance. Review corrections and +repository integration were prepared with OpenAI Codex assistance. They build on the retained +PR #7 finite producers and the preceding contributions credited above. +The new package retains the repository's Apache-2.0 license and the original +authors' attribution. It is not an official OpenAI release or endorsement. + +Modification notice, 8 October 2026 (icekylinx): the retained fast Gaussian +proof now bounds shifted approximation error by F=2^ceil(1.14 alpha^2). +The P=34p precision budget and asymptotic exponent are unchanged. New batching +checks are integrated into make verify. Existing attribution and licenses +are retained. + +Partial-swap extension, 8 October 2026 +Copyright 2026 icekylinx + +The partial-swap framing, binary retained-total triple construction, +dependency-preserving positive labels and carrier reuse, unequal (25,23,57) +common basis, improved complex batching, and exact assembly are contributed +by icekylinx with substantial OpenAI GPT-6 Astra and Codex assistance. +This extension directly inherits PR #10, commit +62691e395a0458ce089a1c7b5d89e74291e95e29. The portable producer adapters +modify the retained paired-exclusion and shared-point implementations credited +above. The original licenses, attribution, and Gaussian correction are retained. + +Endpoint-gauge extension, 8 October 2026 +Copyright 2026 icekylinx + +The complementary auxiliary endpoint gauges, (32,30,40) controlled basis, +general nondegenerate binary phase residuals, retained-center complex producer, +updated path guard and exact assembly are contributed by icekylinx with +substantial OpenAI GPT-6 Astra and Codex assistance. This extension inherits +f2ab41aebad47861caf6316282c1793e5513845e and its PR #10 ancestry. New portable +adapters retain the paired-exclusion and shared-point contributions credited +above. Original licenses, notices and the Gaussian correction are retained. + +Structured-basis and semantic-bulk extension, 8 October 2026 +Copyright 2026 icekylinx + +The selected (32,30,36) bit construction, A1/A5 block refinements, fixed +middle-axis I+J profiles with bounded-minor CRT certificates, mixed dyadic +complex centers, complete data-front batching and circuit-specific assembly +are contributed by icekylinx with substantial OpenAI GPT-6 Astra and Codex +assistance. The immediate parent is ed90fd940279c336ebc45968631bdebfb087b505. + +The semantic/bulk compatibility argument, literal scalar charge, product row +stock and parameterization adapt Zhihao Chen (jacklightChen)'s PR #23, +commit 661ebabc1076c9f525d7ce4967c876b203fa9827. Translated complex endpoints +are adopted from the same contributor's PR #21, +commit 5ba6cf0bfb68f2be8d15610e7972207c50254d6a, following eumemic's source-frame +work and the earlier nested-basis contributions. + +Completed-child semantic precision, arbitrary-coordinate routing, phase-cell +Gaussian inversion and bulk tape transfer are credited to the RaD project +(hipotures), commit 45d9b60355872041f9275f77c057514def0d45bc, exposed through +PR #20 at 4f8d6c8272b5ff307a0da51df545ec3cd96a8b6e. Their selected proof +sources retain their separate CC0 license and original NOTICE under +references/semantic-bulk/rad20. The PR #23 source retains its recorded OpenAI +Codex assistance; RaD retains its recorded Codex and GPT-6.1-Sol Ultra +assistance. These are source attributions, not claims about this session's +runtime model. Related contributions by Rohan Arun and Aurel Prosz remain +acknowledged in the imported notices. No exclusive priority or additional +license condition is asserted. + +Copied retained-center extension, 8 October 2026 +Copyright 2026 icekylinx + +The copied retained-center schedule in both orientations, its complex-phase +transfer, the Wm-N+L rank budget, and the selected (25,23)/(28,28) composition +are contributed by icekylinx with substantial OpenAI GPT-6 Astra and Codex +assistance. This extension inherits PR #32 at +0ef3aeb61f55cc0b321ce6a0ef00acee25cefe52 and the preceding PR #10/#18/#24 work. + +The two-stage topology and paid copied-stream endpoint correction are due +to Aurel Prosz (Paureel), c82d09eb4781b68435e3fa3eb6beea72fa900fab, +through Zhihao Chen (jacklightChen)'s PR #29 unequal-axis composition, +9d963275075fa98f1da821e27757b238dafd6b3c. That source also credits Swapnil +Jain's two-stage development at ae405eb474d1486b2d8aef90139869f927f4836a. + +The contiguous corner method, incidence factorization and exact partition +certificates are due to Rohan Arun (PR #31), method commit +02f68f95369c39955c5ffcfddbd75cd83e26b305. The selected (25,23) certificate +specializes Dominik Scholz's parameterization (PR #33), +a499a345c040aa15b68e984a0904eadc485c7a7e. Their source notices and proof +snapshots are preserved in references/copied-centers. Historical OpenAI +Codex, GPT-6 Astra and Anthropic Claude Opus 5.5 assistance is credited to +the respective imported sources. Existing PR #21/#23 and RaD attribution, +licenses and the Gaussian correction remain in force. + +Copied centers with reversed (23,25) data corners, 2026-10-08 +Rohan Arun with substantial OpenAI Codex assistance supplies the composition, +exact dimension23 controls and cost/assembly integration. James Chang's PR34 +supplies the reversed boundary family; icekylinx's PR36 supplies copied retained +centers and the selected complex graph. The balanced assembly remains attributed +to RaD/hipotures and its PR34 specialization. Retain Dominik Scholz PR33, Rohan +Arun PR31, Zhihao Chen PR29/21/23, Paureel/Aurel Prosz, Swapnil Jain, icekylinx, +eumemic, Douglas Colkitt, OpenAI and all earlier notices and hypotheses. +This is not a claim of formal verification, new foundational rank identities, +global optimality or measured runtime speedup. + +Fixed middle basis with copied reversed corners (2026-10-08): +Rohan Arun, with substantial OpenAI Codex assistance. Composition and +simultaneous-basis proof retain icekylinx PR32/36, James Chang PR34, +Dominik Scholz PR35/38, Zhihao Chen, Paureel, Swapnil Jain, RaD/hipotures, +eumemic and all preceding attribution and licenses. See research/copied-fixed-reversed. + +Changed-graph composition with copied centers and fixed bases, 8 October 2026 +Prepared with OpenAI Codex assistance. +The new composition uses icekylinx PR36 copied centers and PR32 fixed-I+J +projectors/profiler, Dominik Scholz PR35 two fixed factors and CRT argument, +Zhihao Chen (jacklightChen) PR29/23 interfaces, Aurel Prosz (Paureel) and +Swapnil Jain's two-stage development, Rohan Arun PR25/31 corner methods, +Dominik Scholz PR33/38 dimension/composition work; James Chang (jamesyc) +PR34 reversed geometry and balanced transfer; Rohan Arun PR37/39/40 +reversed integration, modular data tests and both-fixed baseline; +RaD (hipotures) PR41 changed scalar DAGs, alternating point order and +independent role compiler; RaD balanced routing/bulk interfaces, and all +retained predecessors. +Complete attribution and the conditional proof boundary are recorded in +research/copied-fixed/PROOF.md; imported originals and source pins are retained. +Original Apache-2.0 and CC0 notices remain applicable. + +Community follow-up integration (PRs #49, #45 and #26), 8 October 2026: +Rohan Arun contributes weighted carrier matching and climbed summand/leave-one-out +orders (PRs #44/#47/#49), with Anthropic Claude assistance. The final construction +composes Chafik Boukhalfa's changed-graph checks, exact rational data recovery and +reordered exclusion sums (PRs #43/#46/#48, OpenAI Codex assistance) with RaD / +hipotures's alternating pair order and independent physical role compiler (#41). +All predecessor attribution and conditional proof interfaces remain in force. + +Alejandro Zarzuelo Urdiales contributes Gaussian parity and canonical arithmetic +proofs, finite tensor execution, profile precision accounting and mixed-center +reference checks (#45), with substantial OpenAI Codex assistance. See +research/gaussian-parity-synthesis/PROVENANCE.md for his full attribution. +Ryan S / princezuda contributes historical Lean certificate arithmetic, algebraic +frame/movement/guard lemmas and independent paired-circuit checks (#26). Original +source notices and historical snapshots are preserved. Neither formal package +claims a full formal proof of the multiplication algorithm or a new kappa. + +Joint frame compilation of skip-prefix strips + +The local compiler and exact finite witnesses were prepared by eumemic with +substantial OpenAI Codex assistance. Avi Eisenberg / ikeboy with Anthropic +Claude assistance supplied the unmodified PR #53 skip-prefix producer. +The pinned PR #48 pipeline is Chafik Boukhalfa's contribution, incorporating +Rohan Arun, RaD / hipotures, icekylinx, Dominik Scholz, James Chang, +Zhihao Chen, Aurel Prosz / Paureel, Swapnil Jain, eumemic, Douglas Colkitt, +OpenAI, David Harvey, Joris van der Hoeven and the earlier contributors +credited in the retained sources. See references/frame-compiler/pr48/NOTICE +and references/frame-compiler/pr53/NOTICE for their original attribution. +No authorship or review by those predecessors is claimed for this compiler. + +Joint dual-skip/frame-compiler composition (2026-10-08) +--------------------------------------------------- +Rohan Gupta / gupt1156 with Anthropic Claude assistance: PR55 dual-skip +scalar graph; original LICENSE and NOTICE are retained under +references/frame-compiler/pr55. eumemic with substantial OpenAI Codex +assistance: PR57 joint reversible frame compiler, serialized physical-word +replay and profile reconstruction. Chafik Boukhalfa with OpenAI Codex +assistance: this composition, independent integration and exact certificate. +Avi Eisenberg / ikeboy, Rohan Arun, RaD / hipotures, icekylinx, and all +predecessor authors retain the notices above and in pinned source files. +No original copyright or Apache-2.0 notice is removed. + +Ranked reclamation after the PR58 joint-dual composition (2026-10-08) +---------------------------------------------------------------- +Chafik Boukhalfa with OpenAI Codex assistance: prioritize retired physical +slots by descending current frame rank, retaining slot ID as the tie-breaker; +complete replay, exact profiles, comparison and adversarial controls. +The dedicated joint_dual_reclaim_compiler.py is derived from eumemic's PR57 +compiler. Its original shared compiler remains byte-identical. The PR55 +producer and all preceding attribution remain unchanged. The complete PR58 +comparison certificate and its original source/proof provenance are retained +under references/frame-compiler/pr58. + +Skip-prefix strip producer, 8 October 2026 +By Avi Eisenberg (ikeboy), with Anthropic Claude (Claude Opus 5.5) +assistance. The skip-prefix leave-one-out strip layout in +research/skip-strips/skip_graph.py is new. Everything else reuses Chafik +Boukhalfa's PR #43/#46/#48 research/copied-fixed pipeline, its verification +code, exact data recovery and support-order sorting, together with: +- Rohan Arun's PR #44 weighted carrier matching optimizer; +- RaD (hipotures) PR #41 alternating point order; +- every predecessor credited above. +Complete attribution and the conditional proof boundary are recorded in +research/skip-strips/PROOF.md. Original Apache-2.0 and CC0 notices remain +applicable. + +Local split-pair skip-prefix research continuation (2026-10-08) +Prepared with substantial OpenAI Codex assistance at the user's request. +New contribution: singleton/pair recursive partition refinement, finite summand +order and moment search, and verified composition with inherited paid clones. +Avi Eisenberg/ikeboy with Anthropic Claude assistance: PR53 skip-prefix strips. +Chafik Boukhalfa with OpenAI Codex assistance: PR54 original-envelope clone +specialization and PR43/46/48 checking interfaces. RaD/hipotures: PR51 +whole-chain/source-partition cloning and earlier producer/interfaces. +Rohan Arun: PR44 weighted matching and earlier fixed/reversed work, with all +stated historical AI assistance. All predecessor notices remain applicable. + +Original-envelope whole-chain clones on skip-prefix strips (research/skip-clones): +Chafik Boukhalfa, prepared with OpenAI Codex assistance. The complete-chain +source-partition clone operation is adapted from RaD / hipotures, PR #51, +with original envelopes retained here. The scalar base is Avi Eisenberg's +PR #53 skip-prefix layout, prepared with Anthropic Claude assistance. +All credited PR #43/#46/#48, PR #44 and earlier code/proof notices remain +in force. This extension is provided under the repository's Apache-2.0 terms. + +Community review checkpoint #50–#61, 8 October 2026 +Maintainer integration and independent arithmetic: Douglas Colkitt, with OpenAI Codex. +Avi Eisenberg / ikeboy: skip-prefix strip framework (#53), with Anthropic Claude. +Rohan Gupta / gupt1156: parallel order search (#50, stated Antigravity assistance) +and dual-suffix strips (#55, Anthropic Claude assistance). +Eumemic: equal-frame joint compilation and paid signal reclamation (#57), with Codex. +Chafik Boukhalfa: original-envelope paid clones (#54), composition (#58) and ranked +reclamation (#60), with Codex. Rohan Arun: order search (#52) and positive-frame +composition (#56), with Anthropic Claude and stated Codex validation assistance. +RaD / hipotures: enlarged frames, source partitions and paid whole-chain clones +(#51), with Codex. Rohan Garg / rohangar1: singleton/pair recursion and paid-clone +composition (#59), with Codex. Alejandro Zarzuelo Urdiales: exact parameter +refinement, scoped Lean arithmetic, matrix/parity and search tools (#61), with +his disclosed multi-tool and Codex assistance. +Parallel #50/#52 records are reviewed and credited without replacing the earlier +climbed-48 implementation; their exact commit history is retained. The separate +#51 witness is retained as research; its source-graph/negative-basis data proof +has not received the same full replay as #56's consumed compiler machinery. +See docs/research/community-round2-review.md for precise validation boundaries. +All earlier licenses, contributions and notices remain applicable. + +Interval strips and core-aware pair assembly + +The interval leave-one-out strips and the core-aware group-pair assembly in +research/pair-assembly were prepared by Avi Eisenberg / ikeboy with Anthropic +Claude assistance. They build on PR #53's skip-prefix pipeline and its +inherited PR #48 sources. The stacked witness in research/pair-assembly/frame +uses eumemic's PR #57 joint frame compiler unchanged; its driver and verifier +are adaptations of PR #57's skip_frame_compiler.py, skip_frame_compose.py and +verify_skip_frame.py. Original notices are retained. + +Stopped product-ring extension, 9 October 2026 +Copyright 2026 icekylinx + +The opposite-bank generic projector factorization, componentwise atom-ring +adapters, stopped recurrence and outer ordinary-interchange conversion, +aligned pair-star producer with rational centers, exact denominator-21 +grid and selected (23,23)/(24,24) composition are contributed by icekylinx +with substantial OpenAI GPT-6 Astra and Codex assistance. This extension +builds on merged PR #36, 11817ccacb564bb7f98789c20dc11d3fece207e3, and is +integrated on upstream main 56b66d58297deca1d7dd130247d720e960f77a37. + +The retained ordinary leaf uses the preceding projector, corner and +copied-center proofs. The selected two-stage topology retains Aurel Prosz +(Paureel), Swapnil Jain and Zhihao Chen's credits; the semantic assembly +retains PR #21/#23 and RaD's attribution. Paired producers, carrier matching, +original source notices and each imported license remain unchanged. + +Partial-gauge extension, 9 October 2026 +Copyright 2026 icekylinx + +The pair-first cube assembly, compatible backward frame enlargement, +partial source-gauge schedule and stopped whole-projector composition are +contributed by icekylinx with substantial OpenAI GPT-6 Astra and Codex +assistance, extending PR #104 at 948ce1510df750f4c18b96bdaef436a86f8bf834. + +The physical deferred bit word, reflected event accounting, fan-order +clarification and signed two-stage endpoint are adopted from Zhihao Chen +(jacklightChen), PR #97, e15350b66e4bf796153a68c240a6cc1b788abe3e, with +Codex assistance. Its deferred readouts, V leaves, lifted frames and frozen +witness originate in Swapnil Jain's 741e7aa078392553815df7926ee17ac5e25a8c38, +with the original Claude disclosure retained. Cyclic interval and core-aware +pair primitives build on Avi Eisenberg (ikeboy), PR #62, +ad0f25ff7b23cff7f08ad237c2254e6ecf74257e, with Anthropic Claude assistance. +Prior two-stage, copied-center, ordinary-leaf, semantic/bulk, routing and +precision credits remain in force. Imported source notices and licenses +are preserved under references/partial-gauge/; see SOURCES.json. + +Three-stage cover extension, 9 October 2026 +Copyright 2026 icekylinx + +The arbitrary-subspace Clifford frame theorem, three-stage Cayley geometry, +weighted q-adic GL cover, unit-lower weighted compiler, charged local-ring +fallback, uniform batching, internal row borrowing and exact composition +are contributed by icekylinx with substantial OpenAI GPT-6 Astra assistance. This +repository integration uses Codex assistance and extends +PR #115, cf60442983c153a3a0f5272ea4713f99eba13c86. + +The selected local complex DAG and support/label replay are adopted from +Copyright 2026 eumemic, PR #117, cbb05ce504d571546d9b7794c186a613c659c3bf, +with its original Apache-2.0 terms and Claude assistance disclosure. +The unchanged bit physical word retains Zhihao Chen (jacklightChen), +PR #97, and Swapnil Jain's underlying witness and assistance notices. +The prior opposite-bank, stopped ordinary-leaf, copied-center, topology, +semantic/bulk, precision and analytic credits remain applicable. +Original source notices and license bytes are preserved in +references/three-stage-cover/pr117/ and references/partial-gauge/. + +Paired-cube and shared-core extension, 9 October 2026 +Copyright 2026 icekylinx + +The paired-coordinate triple-cube identity, signed overlap channels, +original-source involution, coordinate-star centers, concrete frame/carrier +compiler, chronological source gauges, PR97 gauge-subset selection, +orthogonal cross-stage routing and exact supplier/assembly integration +are contributed by icekylinx with substantial OpenAI GPT-6 Astra assistance. +Repository integration uses Codex assistance and extends PR #130 at +6a9970a530119174507904e23592fd59ede19a5d. + +The substantial completed-core workspace-sharing principle is credited to +an664, PR #128, 530588a019b4a74f09180680c9e3961bf649ec89, with its reported +OpenAI Codex assistance. No source code, partition or serialized witness +from that PR is imported. The new routing and paired-motif integration +are described separately and claim no exclusive priority for broad sharing, +paired-coordinate, Fourier or carrier-matching ideas. + +Selected coarse queries restrict the retained eumemic PR #117 positive DAG; +its original Apache-2.0 and Claude assistance notices remain unchanged. +The bit word and original frames retain Zhihao Chen's PR #97 and Swapnil +Jain's frozen witness, notices and historical assistance disclosures. +Earlier generalized Clifford, three-stage, uniform weighted recursion, +ordinary-leaf, semantic/bulk, precision and analytic credits remain in force. +Source-specific license bytes are preserved under references/. + +October 9 recycled-bit integration: +DaysSky (#150), William Porter/hpst3r (#147), Thomas Marchand/Th0rgal (#146), +Rohan Gupta/gupt1156 (#148), James Chang/jamesyc (#124), SovereignSteak (#122). +The original notices and assistance disclosures are retained under research/, +including research/recycled-bit-integration/NOTICE. Andrew Barnes/Bortlesboat +(#101) repairs shared verifiers using rfu08's #64 counterexample. rfu08's +scoped finite and formal-transfer packages are included separately; they do +not establish the full multiplication theorem. Earlier and parallel credits +remain applicable. Douglas Colkitt integrated these with OpenAI Codex assistance. + +SovereignSteak PR151 independently supplies the matching gauge/recycling +composition and the selected 473/10^6 atom refinement; its original package +and assistance disclosure are retained under research/gauge-recycling/. + +October 9 coordinated-frame and completed-entrance-bank integration: +Dugongue PR186, 166a34d75e853e933855f0f7e940fe77c4bb6b8d, builds on +Chafik Boukhalfa/chafreaky's PR181, 7fb2194801e3a10f54772c7f0d5505035a4fc0ad, +and eumemic's PR168 v4, 4a3c769e5c5430e7114c4d3e099ff34664677f17. +The frozen package and prerequisite archive preserve all author, source-license +and assistance notices, including PR175's compiler optimization. DaysSky's +carrier closure, James Chang's terminal substitution and balanced assembly, +geckods' stopping refinements and all preceding framework credits remain. +Rohan Arun's PR185 bootstrap and chafreaky's PR182 bit refinement are reviewed +parallel contributions; their gains are not added to the selected witness. +Douglas Colkitt integrated the package and supplied the bank scheduling +supplement with OpenAI Codex assistance, under Apache-2.0. The all-size +interfaces remain conditional; finite verification is not full formalization. diff --git a/research/lean-count-receipt-amortization/PROVENANCE.json b/research/lean-count-receipt-amortization/PROVENANCE.json new file mode 100644 index 0000000000..0219a6a810 --- /dev/null +++ b/research/lean-count-receipt-amortization/PROVENANCE.json @@ -0,0 +1,197 @@ +{ + "status": "PUBLIC_REPRODUCTION_PASS_WITH_GUARDED_RESUMED_SUFFIX", + "package_role": "three-source PR64 arithmetic extraction and concrete receipt transport supplement", + "included_sources": [ + { + "module": "RippleCounterListData", + "candidate": "RippleCounterListData.lean", + "public_sha256": "6ad007faa04e8f22895489011f48c6574dca4a31809f3456fbcf5bea4a5bb302", + "bytes": 1005, + "accepted_sha256": "6ad007faa04e8f22895489011f48c6574dca4a31809f3456fbcf5bea4a5bb302", + "comment_only_change": false + }, + { + "module": "CounterArithmeticPure", + "candidate": "CounterArithmeticPure.lean", + "public_sha256": "7fea5026e56a66f10bcda803c1c8b6f5b3745f029840cc09eb4f6fa197990e0b", + "bytes": 11111, + "accepted_sha256": "1ad26524cc5932842e8f233aa3b8b4f9c0ecb12a4ab06478c6c6f0c42827144b", + "comment_only_change": true + }, + { + "module": "BinaryCountReceiptAmortization", + "candidate": "BinaryCountReceiptAmortization.lean", + "public_sha256": "48f51cf3387fbcd88c75f05bd7714716be33b5590f976a3519fa025ea64bba08", + "bytes": 4763, + "accepted_sha256": "48f51cf3387fbcd88c75f05bd7714716be33b5590f976a3519fa025ea64bba08", + "comment_only_change": false + } + ], + "accepted_research_manifest_sha256": "4ba7d5d47122bc35d0a2acafd13f4a5f5104269be627881d02d2ba16238878f4", + "public_comment_audit_sha256": "f115451ff6a08980b64382581c895bc52bf05a9ff12cdb79dda0fc8abf49172d", + "public_arithmetic_change": "prominent attribution/modification notice only beyond accepted source1ad26524", + "external_packages": [ + { + "pr": 519, + "head": "ffd3c48a80ba8b579dc300e785e387fe8acddfef", + "path": "research/lean-automatic-width-count", + "modules": [ + "BinaryCountDispatcherMarkedInput", + "BinaryCounterZeroAllocation", + "BinaryAutomaticWidthCount" + ] + }, + { + "pr": 511, + "head": "79f7c03c7f820ab89955b75ef239cbaccc627e6e", + "path": "research/lean-binary-count-dispatcher", + "modules": [ + "CarryTape", + "CarryTapePass", + "BinaryCarryIncrement", + "BinaryCountDispatcher" + ] + }, + { + "pr": 488, + "head": "edd3102b415df5b9d6f633ac0a4dedcf69c58525", + "path": "research/lean-binary-input-preparation", + "modules": [ + "IntegerConvolution", + "FixedTapeMachine" + ] + } + ], + "external_source_pins": [ + { + "module": "IntegerConvolution", + "origin": "pr488", + "file": "Lean/IntegerConvolution.lean", + "sha256": "0bc86f2fa8e68f39df77be603d2a9634bc008745093286903105378ab45938ea", + "bytes": 2055 + }, + { + "module": "FixedTapeMachine", + "origin": "pr488", + "file": "Lean/FixedTapeMachine.lean", + "sha256": "92dadedc9f6e23d12633549b53ca8f917360e4fedac0b64a58d18feea741a5ed", + "bytes": 4523 + }, + { + "module": "CarryTape", + "origin": "pr511", + "file": "CarryTape.lean", + "sha256": "20d13d9d2da74452e45c0a175b643556615ba14187bf8fb0e4393e44842c17a5", + "bytes": 8348 + }, + { + "module": "CarryTapePass", + "origin": "pr511", + "file": "CarryTapePass.lean", + "sha256": "680b5d16736880ac6a02f27e9503e1cc01479bb2b35bb7546d9108dcb4b4ef2b", + "bytes": 5662 + }, + { + "module": "BinaryCarryIncrement", + "origin": "pr511", + "file": "BinaryCarryIncrement.lean", + "sha256": "b0f639159e2169c75e6d7a13663adee5107648a32b7ff9203f92792e31012dce", + "bytes": 9032 + }, + { + "module": "BinaryCountDispatcher", + "origin": "pr511", + "file": "BinaryCountDispatcher.lean", + "sha256": "ec24af9483d59ce3248802378218d4b478490aa2458e136880f36e7f49356e93", + "bytes": 14544 + }, + { + "module": "BinaryCountDispatcherMarkedInput", + "origin": "pr519", + "file": "BinaryCountDispatcherMarkedInput.lean", + "sha256": "b7f0cecb69194b8d851037e8321e245dc383c62e3e2475c9d4508d29390191cc", + "bytes": 10257 + }, + { + "module": "BinaryCounterZeroAllocation", + "origin": "pr519", + "file": "BinaryCounterZeroAllocation.lean", + "sha256": "5cf3fdfcd6c6a6cefa89b9a83dc678b6f40d9a608c318334ae92a66d25ea7477", + "bytes": 9595 + }, + { + "module": "BinaryAutomaticWidthCount", + "origin": "pr519", + "file": "BinaryAutomaticWidthCount.lean", + "sha256": "5dcf4ec74f08d9662738db413d144e16f4b555e56f29e0846ad5c88726420154", + "bytes": 10124 + } + ], + "runtime": { + "lean": "4.21.0", + "mathlib_revision": "308445d7985027f538e281e18df29ca16ede2ba3", + "entry_imports": [ + "Mathlib.Algebra.Group.Nat.Defs", + "Mathlib.Tactic.SplitIfs" + ], + "cached_core_and_external_module_count": 1366, + "total_graph_modules": 1378, + "network_or_import_expansion": false, + "source_and_object_manifest": "EXTERNAL_OBJECTS.json" + }, + "upstream": { + "pr": 64, + "source_manifest_sha256": "52b90f192bac57463810cff8aeb6ffc086fa41f33f0277cbdfe26ae805e45075", + "RippleCounter_sha256": "2278a5fd158bd953f136204d92c9da0e6d9fc39fb1a74e8792e8e46aa0d2bc5a", + "CounterArithmetic_sha256": "00caa87ed92bd65ac6a2535a58faba438f887cc6b137c4cfb28a1df403628554", + "license_review_sha256": "5527f3fb95f00f48cc555558467a5dccced5b92e02b53fcf9c647c19ac660101" + }, + "license": { + "identifier": "Apache-2.0", + "license_sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "applicable_notice_sha256": "b49022cb4104d90b182e4c335f670faf45529025b15db77bf0291835083c28bd", + "source_correspondence_required": true, + "not_RaD_CC0": true + }, + "conditional_project_context": { + "base": "12a4934d15006e8c10f9b2264f13f8f341be802b", + "kappa": "90446448750933/125000000000000000", + "decimal": "0.000723571590007464", + "selected_result_sha256": "df836c6d34509e980d067bd5678489c968bc6e329af9dd82c6207abf6443da89", + "linked_certificate_sha256": "6a457a34b4db57417e5b253cf1c169da2bd6aff4c21363a31fd85dc931d49589", + "author_checked_exact_rational_decimal_and_link": true, + "no_multiplier_or_kappa_theorem_from_this_chunk": true + }, + "research_acceptance_sha256": "0240d296078cbd063d9318291bfff1b50fc9a8e3240f23fd0965819cdbea38ed", + "terminal_review_sha256": "fe9953b31332c197d1aaf462a61ed160c95e3f248adfbef583449c7cbb14b42e", + "claims": [ + "pass reads equals totalSteps true n bits+2n", + "pass reads<=6n+2width", + "same actual automatic-width machine reaches finalConfiguration at some t<=12n+4" + ], + "not_claimed": [ + "first completion", + "compact canonical counter output", + "source input4 caller composition", + "Plan/carry or represented-list Budget", + "multiplication theorem or kappa theorem" + ], + "isolated_public_replay": { + "summary": "REPLAY_SUMMARY.json", + "sha256": "274c3dc5c100dd125ef41af06778cde816faf70da321aced4e5fa55eb04fffd0", + "roots": 12, + "retained_verified_prefix": 10, + "new_suffix": 2, + "all79_expected_probes_match": true, + "research_object_matches": 11, + "public_arithmetic_object_sha256": "fbeef1327323a7b85940eff1f506eb3f4eb840a40ac9a1bacf8980ae09509e98", + "syntax_failure_preserved": true + }, + "package_manifest": "MANIFEST.json", + "public_opener_repair": { + "failed_public_source_sha256": "9572c02fdef712c5bec1b206e293aabc50f3cf8ce233b57f8c0302a10d5372c7", + "repaired_public_source_sha256": "7fea5026e56a66f10bcda803c1c8b6f5b3745f029840cc09eb4f6fa197990e0b", + "change": "Delete only the exclamation mark in the initial module-doc opener, making it an ordinary comment so import remains the first command. All notice words and scientific bytes unchanged.", + "author_readback_sha256": "aed5c48a21dd66f801c6aedc4d4773bb9f9519b240c578f00c66d2aa8ea0d551" + } +} diff --git a/research/lean-count-receipt-amortization/PUBLIC_SOURCE_CHANGES.json b/research/lean-count-receipt-amortization/PUBLIC_SOURCE_CHANGES.json new file mode 100644 index 0000000000..5abacc0c17 --- /dev/null +++ b/research/lean-count-receipt-amortization/PUBLIC_SOURCE_CHANGES.json @@ -0,0 +1,54 @@ +{ + "status": "EXACT_PUBLIC_NOTICE_TRANSITION_AND_REPRODUCTION_COMPLETED", + "utc": "2026-10-12T00:25:19.615453+00:00", + "exact_comment": "/-\nPR64 upstream attribution and modification notice\n\nThis file adapts CounterArithmetic.lean from the published PR64 counter work:\nhttps://github.com/CrocSwap/integer-mult-bounds/pull/64\nOriginal path: research/machine-transfer-verification/stream-transfer/counters/CounterArithmetic.lean\nOriginal SHA-256: 00caa87ed92bd65ac6a2535a58faba438f887cc6b137c4cfb28a1df403628554\nThe original source is recorded in the publication manifest at current-main\n12a4934d15006e8c10f9b2264f13f8f341be802b.\n\nModifications: retarget the import to the exact five-definition\nRippleCounterListData extraction; locally register the installed Nat.le_refl\nand Nat.mul_eq_zero theorems; and select synchronous module elaboration with\nElab.async=false. All original mathematical declaration/proof bodies and\n23 axiom probes are retained. The public packaging copy adds only this notice\nto the separately accepted adapted source. No new potential proof is claimed.\n\nRepository license: Apache-2.0. See the accompanying LICENSE, NOTICE and\nPROVENANCE.json for attribution, exact correspondence and dependency pins.\n-/\n\n", + "inverse_verified": true, + "imports_statements_proofs_probes_and_module_names_unchanged": true, + "accepted_research_sources_untouched": true, + "comment_bytes": 1092, + "sources": [ + { + "module": "RippleCounterListData", + "public_sha256": "6ad007faa04e8f22895489011f48c6574dca4a31809f3456fbcf5bea4a5bb302", + "bytes": 1005, + "accepted_sha256": "6ad007faa04e8f22895489011f48c6574dca4a31809f3456fbcf5bea4a5bb302", + "comment_only_change": false, + "file": "RippleCounterListData.lean" + }, + { + "module": "CounterArithmeticPure", + "public_sha256": "7fea5026e56a66f10bcda803c1c8b6f5b3745f029840cc09eb4f6fa197990e0b", + "bytes": 11111, + "accepted_sha256": "1ad26524cc5932842e8f233aa3b8b4f9c0ecb12a4ab06478c6c6f0c42827144b", + "comment_only_change": true, + "file": "CounterArithmeticPure.lean" + }, + { + "module": "BinaryCountReceiptAmortization", + "public_sha256": "48f51cf3387fbcd88c75f05bd7714716be33b5590f976a3519fa025ea64bba08", + "bytes": 4763, + "accepted_sha256": "48f51cf3387fbcd88c75f05bd7714716be33b5590f976a3519fa025ea64bba08", + "comment_only_change": false, + "file": "BinaryCountReceiptAmortization.lean" + } + ], + "notice_syntax_repair": { + "status": "AUTHOR_CHECKED_ONE_BYTE_PUBLIC_NOTICE_REPAIR", + "utc": "2026-10-12T00:39:11.350311+00:00", + "failed_public_sha256": "9572c02fdef712c5bec1b206e293aabc50f3cf8ce233b57f8c0302a10d5372c7", + "candidate_sha256": "7fea5026e56a66f10bcda803c1c8b6f5b3745f029840cc09eb4f6fa197990e0b", + "accepted_research_sha256": "1ad26524cc5932842e8f233aa3b8b4f9c0ecb12a4ab06478c6c6f0c42827144b", + "edit": "Delete ! from the leading /-! opener, producing an ordinary block comment before imports.", + "changed_bytes": 1, + "every_notice_word_and_scientific_byte_unchanged": true, + "inverse_verified": true, + "notice_bytes_old": 1093, + "notice_bytes_new": 1092, + "accepted_research_source_untouched": true, + "import_is_now_first_command": true, + "no_theorem_or_kappa_change": true, + "actual_reproduction_pending": true + }, + "historical_readback_note": "Embedded source-only author readback predates the separately completed resumed reproduction.", + "public_replay_summary_sha256": "274c3dc5c100dd125ef41af06778cde816faf70da321aced4e5fa55eb04fffd0" +} diff --git a/research/lean-count-receipt-amortization/README.md b/research/lean-count-receipt-amortization/README.md new file mode 100644 index 0000000000..d39ded0480 --- /dev/null +++ b/research/lean-count-receipt-amortization/README.md @@ -0,0 +1,62 @@ +# PR64 receipt transport for the automatic-width counter + +This three-source supplement connects the published PR64 fixed-direction arithmetic bound to the concrete automatic-width binary counter from PR519. It reuses the original potential proof and the previously checked machine; it adds the exact receipt correspondence between their interfaces. + +## Checked result + +For every finite Boolean word of length n, CurrentMain.BinaryCountReceiptAmortization.count_run_linear gives an elapsed t <= 12*n+4 at which the existing ten-state, two-tape machine reaches its exact final configuration. + +The input head starts at the represented right blank after the whole word: . The counter tape starts pristine. The final state is 9, the final input tape is , and the counter is the width-n marked-home representation of the inherited n-step pass from n zero bits. PR519's accepted endpoint theorems give stored value exactly n and terminal halting. Empty input is included. The theorem does not identify first completion or a canonical short output record. + +The receipt equality is exact for every width and starting word: current pass reads = CounterArithmetic.totalSteps true n bits + 2*n. PR64's 4*n+2*width bound therefore yields current pass reads <= 6*n+2*width. PR519 supplies allocation/controller overhead 4*n+4, giving 12*n+4 at width n. Wraparound and width zero remain covered in the general receipt statements; the automatic-width counter separately stores the exact input length. + +## What is included + +- RippleCounterListData.lean extracts PR64's five unchanged list definitions, with the original RippleCounter namespace. +- CounterArithmeticPure.lean retains all original CounterArithmetic declaration and proof bodies and 23 probes. Its import is retargeted to the extraction, two installed-core theorems are registered locally, and Elab.async=false is selected inside a local section. This public copy adds a prominent modification notice to the accepted adapted source. +- BinaryCountReceiptAmortization.lean proves seven interface facts, culminating in the 12*n+4 endpoint theorem. + +PR64 already proves richer generic counter results, including both directions, arbitrary exterior tape, first completion and fixed-direction amortization. This package claims no new generic counter algorithm or potential proof and no simulation of PR64's complete tape machine. PR519's source and published unamortized pass.reads+4*n+4 theorem stay unchanged. + +## Exact external proof dependencies + +Use the recorded sources from three separate worktrees; no merged status is assumed: + +- PR519, ffd3c48a80ba8b579dc300e785e387fe8acddfef, research/lean-automatic-width-count: BinaryCountDispatcherMarkedInput, BinaryCounterZeroAllocation, BinaryAutomaticWidthCount. +- PR511, 79f7c03c7f820ab89955b75ef239cbaccc627e6e, research/lean-binary-count-dispatcher: CarryTape, CarryTapePass, BinaryCarryIncrement, BinaryCountDispatcher. +- PR488, edd3102b415df5b9d6f633ac0a4dedcf69c58525, research/lean-binary-input-preparation: IntegerConvolution and FixedTapeMachine. + +All nine dependency source hashes are pinned in the package provenance/manifest. The PR511 source pin above is intentional; its later CI-provenance repair head is a separate artifact. + +## Runtime and reproduction boundary + +This is a Lean 4.21.0 package with Mathlib revision 308445d7985027f538e281e18df29ca16ede2ba3. It is not core-only. The Mathlib entry imports are Mathlib.Algebra.Group.Nat.Defs and Mathlib.Tactic.SplitIfs; the exact accepted source/object dependency closure is required for offline reproduction. No download, installation or broader import is implied. The original physical TapeStack, RippleCounter and CounterArithmetic modules are excluded. Do not jointly import their original declaration-defining modules with these namespace-preserving extractions. + +The exact public twelve-source reproduction is complete, with all 79 expected standard-only probes matching. It used 17.7186 compiler seconds and 0.00557 FIFO seconds across ten retained verified checks and a separately guarded two-root suffix; peak VM was 3,074,072,576 bytes. The first public notice used a module-doc opener before an import and was rejected; the one-byte ordinary-comment correction and failed evidence are retained. Eleven object hashes match research; the public arithmetic copy has a distinct accepted object, with the same scientific body and 23 probes. REPLAY_SUMMARY.json records the full resumed sequence. Hard limits remain 60 seconds and 4 GiB per root, with review at 40 seconds or 3.5 GiB. + +## Attribution and license + +PR64 is the source of the five literal definitions and complete arithmetic proof bodies. Preserve the upstream hashes and source correspondence in PROVENANCE.json. The package carries Apache-2.0 LICENSE, the applicable repository NOTICE, and explicit extraction/import/control-change notices. The existing repository's separate RaD CC0 exception does not apply to these counter files. + +## Author-checked conditional project context + +At current-main base 12a4934d15006e8c10f9b2264f13f8f341be802b, certificates/selected-result.json records kappa = 90446448750933/125000000000000000 = 0.000723571590007464 and links the retained PR279 certificate by its exact SHA-256. The rational/decimal equality and selected-result/certificate linkage were checked. This is the source's conditional project parameter. These generic counter and receipt-transport modules prove no multiplication or kappa theorem. + +Compact record normalization/copy, the actual input-preparation-to-counter finite-control composition, the selected source caller and Plan/carry construction, and the whole Gaussian represented-list Budget remain separate. The retained all-size compiler, chart/routing, prime supply, precision/recovery, complex symbolic correctness and analytic-transfer conditions are not discharged by this package. + +## Offline reproduction + +Use Linux, Python 3, the official Lean 4.21.0 distribution, and an already prepared Mathlib checkout at the revision above with its existing package caches. The checker does not download or build Mathlib. EXTERNAL_OBJECTS.json lists all 1,300 official-core and 66 noncore source/object hashes used by this closure; hash or first-match path differences stop before compilation. + +Provide the three exact source worktrees described above. From this flat package directory, run: + +```sh +python3 check.py --lean /path/to/lean-4.21.0-linux/bin/lean \ + --mathlib-root /path/to/mathlib4 \ + --input-foundation-root /path/to/PR488/research/lean-binary-input-preparation \ + --dispatcher-foundation-root /path/to/PR511/research/lean-binary-count-dispatcher \ + --automatic-width-root /path/to/PR519/research/lean-automatic-width-count \ + --build-dir /path/to/new-empty-reproduction-directory +``` + +The build directory must not exist. The checker copies only the twelve verified source files into a new source directory, compiles into a separate fresh object directory, and supplies only that output plus the eight explicit cache paths. It ignores inherited Lean search/sysroot settings. Every local source, all dependency identities and all79 complete axiom probes are checked; logs and per-root receipts are retained. A failure or review threshold stops the remaining sequence. The optional --slot-service argument reuses an existing FIFO admission service; it changes no Lean input. diff --git a/research/lean-count-receipt-amortization/REPLAY_SUMMARY.json b/research/lean-count-receipt-amortization/REPLAY_SUMMARY.json new file mode 100644 index 0000000000..50faa6fc54 --- /dev/null +++ b/research/lean-count-receipt-amortization/REPLAY_SUMMARY.json @@ -0,0 +1,1036 @@ +{ + "status": "PASS_COMPLETE_ISOLATED_REPRODUCTION_WITH_GUARDED_TEN_ROOT_PREFIX_AND_TWO_ROOT_SUFFIX", + "recorded_utc": "2026-10-12T00:45:09.530521+00:00", + "sources": 12, + "included_sources": 3, + "external_pr_sources": 9, + "source_bytes": 91019, + "external_runtime_modules": 1366, + "result_sha256": "f980d719f9ee75ff6e828b738e5e4ebedeb127437dfb5dc2531eaae3af04b386", + "public_manifest_sha256": "169758c45c3f0ab3b48920793d766ecdd5221e56e72cb9683a8681c6f75bfacb", + "checker_sha256": "ba21a7de1547b79161d17d4c9f2c8a1c6a4806ffa9681d3acd1bc65ba066d2f2", + "external_manifest_sha256": "2e29aae6cd405281d34d718395ab98f4adab083c64b34341fa7c8a879e6a1dd1", + "dependency_manifest_sha256": "324158e7e76ba677bfe3cbd4aa092c3cb87bb04065d6bb12d78dcdb89a991be6", + "prefix_reused": 10, + "suffix_checked": 2, + "compiler_seconds": 17.718593240009795, + "queue_seconds": 0.00556656200933503, + "peak_vm_bytes": 3074072576, + "suffix_compiler_seconds": 3.283855579004012, + "initial_notice_failure_compiler_seconds": 0.18082231399966986, + "initial_notice_failure_preserved": true, + "review_caps": { + "seconds": 40, + "vm_bytes": 3758096384 + }, + "hard_caps": { + "seconds": 60, + "vm_bytes": 4294967296 + }, + "complete_standard_probe_count": 79, + "all_expected_probes_match": true, + "research_object_matches": 11, + "object_comparison_note": "Eleven objects match the accepted research artifacts. CounterArithmeticPure has a distinct public object after the one-byte-corrected prominent notice insertion; its scientific body and all23 probes remain exact. No object equality was assumed for this public copy.", + "full_log_comparison_note": "Eleven complete logs are byte-identical; BinaryCountDispatcher differs only by source-path presentation in a warning.", + "reproduction_sequence": "The first run accepted ten unchanged sources, then rejected the leading module-doc notice before an import. Failed public bytes/log/receipt were preserved. Removing only the opener exclamation mark was author- and independently reviewed. A separately reviewed driver verified every retained source/object/receipt/log and compiled only arithmetic plus bridge in a new isolated output using those ten copied exact objects. This is a guarded resumed reproduction, not a second full replay.", + "modules": [ + { + "module": "IntegerConvolution", + "source_sha256": "0bc86f2fa8e68f39df77be603d2a9634bc008745093286903105378ab45938ea", + "status": "PASS", + "review_stop": false, + "exit_code": 0, + "timed_out": false, + "started_utc": "2026-10-12T00:37:39.940677+00:00", + "finished_utc": "2026-10-12T00:37:40.804694+00:00", + "compile_seconds": 0.8634388630016474, + "queue_seconds": 0.0006284260016400367, + "peak_vm_bytes": 2265145344, + "peak_rss_bytes": 1000194048, + "peak_threads": 7, + "samples": 9, + "complete_axiom_probes": [ + { + "declaration": "CurrentMain.IntegerConvolution.value_addCoefficients", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CurrentMain.IntegerConvolution.value_map_mul", + "axioms": [ + "propext" + ] + }, + { + "declaration": "CurrentMain.IntegerConvolution.convolution_value", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CurrentMain.IntegerConvolution.binary_convolution", + "axioms": [ + "propext", + "Quot.sound" + ] + } + ], + "expected_probes_match": true, + "slot": 0, + "log_sha256": "c1aea8c6ec85d16aa991288c1dbd640d2047900b669fb59a79e5d084d150f0c5", + "object_sha256": "72299b15d1bee37af56e1c5d10018d45784213c43461021afc4c213d1863af36", + "imports": [ + "Lean" + ], + "axiom_output": [ + "'CurrentMain.IntegerConvolution.value_addCoefficients' depends on axioms: [propext, Quot.sound]", + "'CurrentMain.IntegerConvolution.value_map_mul' depends on axioms: [propext]", + "'CurrentMain.IntegerConvolution.convolution_value' depends on axioms: [propext, Quot.sound]", + "'CurrentMain.IntegerConvolution.binary_convolution' depends on axioms: [propext, Quot.sound]" + ], + "receipt_sha256": "3f00859fccda37e2bd0381ead6afe43a33d8580389c6f4e3c5b9c1a0b70cb5c8", + "reused_verified_prefix": true, + "research_source_sha256": "0bc86f2fa8e68f39df77be603d2a9634bc008745093286903105378ab45938ea", + "research_object_sha256": "72299b15d1bee37af56e1c5d10018d45784213c43461021afc4c213d1863af36", + "matches_research_object": true, + "matches_research_full_log": true + }, + { + "module": "FixedTapeMachine", + "source_sha256": "92dadedc9f6e23d12633549b53ca8f917360e4fedac0b64a58d18feea741a5ed", + "status": "PASS", + "review_stop": false, + "exit_code": 0, + "timed_out": false, + "started_utc": "2026-10-12T00:37:40.806207+00:00", + "finished_utc": "2026-10-12T00:37:41.865251+00:00", + "compile_seconds": 1.058651772000303, + "queue_seconds": 0.0005038130002503749, + "peak_vm_bytes": 2063859712, + "peak_rss_bytes": 1008545792, + "peak_threads": 6, + "samples": 11, + "complete_axiom_probes": [ + { + "declaration": "CurrentMain.FixedTapeMachine.initial_inputA", + "axioms": [ + "propext" + ] + }, + { + "declaration": "CurrentMain.FixedTapeMachine.initial_inputB", + "axioms": [ + "propext" + ] + }, + { + "declaration": "CurrentMain.FixedTapeMachine.initial_output", + "axioms": [ + "propext" + ] + }, + { + "declaration": "CurrentMain.FixedTapeMachine.run_halted", + "axioms": [] + }, + { + "declaration": "CurrentMain.FixedTapeMachine.run_add", + "axioms": [ + "propext" + ] + } + ], + "expected_probes_match": true, + "slot": 0, + "log_sha256": "36dc8dbc05e17722f16160959d84aea237a472b8a2435c0fd7dc140e3f704559", + "object_sha256": "88fa2e0c9e43f696f53762a345092d19fa3501d7b1de2381dfb335b232b53ff1", + "imports": [ + "IntegerConvolution" + ], + "axiom_output": [ + "'CurrentMain.FixedTapeMachine.initial_inputA' depends on axioms: [propext]", + "'CurrentMain.FixedTapeMachine.initial_inputB' depends on axioms: [propext]", + "'CurrentMain.FixedTapeMachine.initial_output' depends on axioms: [propext]", + "'CurrentMain.FixedTapeMachine.run_halted' does not depend on any axioms", + "'CurrentMain.FixedTapeMachine.run_add' depends on axioms: [propext]" + ], + "receipt_sha256": "768aceff0f949526574fafde06cb0f5eb15b6ae064744326404324d3fb65f7fb", + "reused_verified_prefix": true, + "research_source_sha256": "92dadedc9f6e23d12633549b53ca8f917360e4fedac0b64a58d18feea741a5ed", + "research_object_sha256": "88fa2e0c9e43f696f53762a345092d19fa3501d7b1de2381dfb335b232b53ff1", + "matches_research_object": true, + "matches_research_full_log": true + }, + { + "module": "CarryTape", + "source_sha256": "20d13d9d2da74452e45c0a175b643556615ba14187bf8fb0e4393e44842c17a5", + "status": "PASS", + "review_stop": false, + "exit_code": 0, + "timed_out": false, + "started_utc": "2026-10-12T00:37:41.866824+00:00", + "finished_utc": "2026-10-12T00:37:43.325375+00:00", + "compile_seconds": 1.4580247390003933, + "queue_seconds": 0.0002903400018112734, + "peak_vm_bytes": 2736443392, + "peak_rss_bytes": 1027846144, + "peak_threads": 10, + "samples": 15, + "complete_axiom_probes": [ + { + "declaration": "CurrentMain.CarryTape.run_add", + "axioms": [ + "propext" + ] + }, + { + "declaration": "CurrentMain.CarryTape.carry_execution", + "axioms": [ + "propext" + ] + }, + { + "declaration": "CurrentMain.CarryTape.rewind_execution", + "axioms": [ + "propext" + ] + }, + { + "declaration": "CurrentMain.CarryTape.carryFinish_rewind", + "axioms": [ + "propext" + ] + }, + { + "declaration": "CurrentMain.CarryTape.increment_execution", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CurrentMain.CarryTape.increment_length", + "axioms": [ + "propext" + ] + }, + { + "declaration": "CurrentMain.CarryTape.all_ones_execution", + "axioms": [ + "propext", + "Quot.sound" + ] + } + ], + "expected_probes_match": true, + "slot": 0, + "log_sha256": "a269b42e17b5fd794216654bafc3ee3cc58c39fbbf5c36fa525eb42bfc739b67", + "object_sha256": "5ecb25ccf73c61eb5b4be13a69c73d9b7183201a71344e333761af7ea7915c74", + "imports": [ + "Lean" + ], + "axiom_output": [ + "'CurrentMain.CarryTape.run_add' depends on axioms: [propext]", + "'CurrentMain.CarryTape.carry_execution' depends on axioms: [propext]", + "'CurrentMain.CarryTape.rewind_execution' depends on axioms: [propext]", + "'CurrentMain.CarryTape.carryFinish_rewind' depends on axioms: [propext]", + "'CurrentMain.CarryTape.increment_execution' depends on axioms: [propext, Quot.sound]", + "'CurrentMain.CarryTape.increment_length' depends on axioms: [propext]", + "'CurrentMain.CarryTape.all_ones_execution' depends on axioms: [propext, Quot.sound]" + ], + "receipt_sha256": "6a0876e1f84d4620011353821111734c8dcd987f1c904e2eb7b639fc8754da5f", + "reused_verified_prefix": true, + "research_source_sha256": "20d13d9d2da74452e45c0a175b643556615ba14187bf8fb0e4393e44842c17a5", + "research_object_sha256": "5ecb25ccf73c61eb5b4be13a69c73d9b7183201a71344e333761af7ea7915c74", + "matches_research_object": true, + "matches_research_full_log": true + }, + { + "module": "CarryTapePass", + "source_sha256": "680b5d16736880ac6a02f27e9503e1cc01479bb2b35bb7546d9108dcb4b4ef2b", + "status": "PASS", + "review_stop": false, + "exit_code": 0, + "timed_out": false, + "started_utc": "2026-10-12T00:37:43.327096+00:00", + "finished_utc": "2026-10-12T00:37:45.025134+00:00", + "compile_seconds": 1.688716464999743, + "queue_seconds": 0.0003046319980057888, + "peak_vm_bytes": 2735955968, + "peak_rss_bytes": 1016791040, + "peak_threads": 10, + "samples": 17, + "complete_axiom_probes": [ + { + "declaration": "CurrentMain.CarryTape.value_bound", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CurrentMain.CarryTape.increment_value", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CurrentMain.CarryTape.increment_mod", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CurrentMain.CarryTape.pass_length", + "axioms": [ + "propext" + ] + }, + { + "declaration": "CurrentMain.CarryTape.pass_value", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CurrentMain.CarryTape.pass_even", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CurrentMain.CarryTape.empty_pass_one", + "axioms": [] + }, + { + "declaration": "CurrentMain.CarryTape.complete_pass", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CurrentMain.CarryTape.incrementReceipt_realized", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CurrentMain.CarryTape.pass_successor_realized", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CurrentMain.CarryTape.full_pass24_index_traffic", + "axioms": [ + "propext", + "Quot.sound" + ] + } + ], + "expected_probes_match": true, + "slot": 0, + "log_sha256": "bf3a993154b0837224b4a4f76d6f48fc6508422904a4371309c777ba6936ddb6", + "object_sha256": "183f0edf242a2f6ecb9d9a07d62bc977d9fa04b3a32bad75a6c71344583c1147", + "imports": [ + "CarryTape" + ], + "axiom_output": [ + "'CurrentMain.CarryTape.value_bound' depends on axioms: [propext, Quot.sound]", + "'CurrentMain.CarryTape.increment_value' depends on axioms: [propext, Quot.sound]", + "'CurrentMain.CarryTape.increment_mod' depends on axioms: [propext, Quot.sound]", + "'CurrentMain.CarryTape.pass_length' depends on axioms: [propext]", + "'CurrentMain.CarryTape.pass_value' depends on axioms: [propext, Quot.sound]", + "'CurrentMain.CarryTape.pass_even' depends on axioms: [propext, Quot.sound]", + "'CurrentMain.CarryTape.empty_pass_one' does not depend on any axioms", + "'CurrentMain.CarryTape.complete_pass' depends on axioms: [propext, Quot.sound]", + "'CurrentMain.CarryTape.incrementReceipt_realized' depends on axioms: [propext, Quot.sound]", + "'CurrentMain.CarryTape.pass_successor_realized' depends on axioms: [propext, Quot.sound]", + "'CurrentMain.CarryTape.full_pass24_index_traffic' depends on axioms: [propext, Quot.sound]" + ], + "receipt_sha256": "4006120dffb5c5adaaabafaba801b8cf5e3c311018a63bc3ca3f266a3e313b34", + "reused_verified_prefix": true, + "research_source_sha256": "680b5d16736880ac6a02f27e9503e1cc01479bb2b35bb7546d9108dcb4b4ef2b", + "research_object_sha256": "183f0edf242a2f6ecb9d9a07d62bc977d9fa04b3a32bad75a6c71344583c1147", + "matches_research_object": true, + "matches_research_full_log": true + }, + { + "module": "BinaryCarryIncrement", + "source_sha256": "b0f639159e2169c75e6d7a13663adee5107648a32b7ff9203f92792e31012dce", + "status": "PASS", + "review_stop": false, + "exit_code": 0, + "timed_out": false, + "started_utc": "2026-10-12T00:37:45.026855+00:00", + "finished_utc": "2026-10-12T00:37:46.302364+00:00", + "compile_seconds": 1.2750285820002318, + "queue_seconds": 0.000296568003250286, + "peak_vm_bytes": 2065469440, + "peak_rss_bytes": 1010016256, + "peak_threads": 6, + "samples": 13, + "complete_axiom_probes": [ + { + "declaration": "CurrentMain.BinaryCarryIncrement.increment_run", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CurrentMain.BinaryCarryIncrement.final_halted", + "axioms": [ + "propext" + ] + }, + { + "declaration": "CurrentMain.BinaryCarryIncrement.increment_length", + "axioms": [ + "propext" + ] + }, + { + "declaration": "CurrentMain.BinaryCarryIncrement.value_binding", + "axioms": [] + }, + { + "declaration": "CurrentMain.BinaryCarryIncrement.increment_modular_value", + "axioms": [ + "propext", + "Quot.sound" + ] + } + ], + "expected_probes_match": true, + "slot": 0, + "log_sha256": "d249a6aaa4e3eec29d84596b492eac68b52d6c14c115df389f20f5b313d1f0ae", + "object_sha256": "07895c550c6298ae2143cca61c53399131f4b5a6a77b71f154c7ec6baa46ddc8", + "imports": [ + "FixedTapeMachine", + "CarryTapePass" + ], + "axiom_output": [ + "'CurrentMain.BinaryCarryIncrement.increment_run' depends on axioms: [propext, Quot.sound]", + "'CurrentMain.BinaryCarryIncrement.final_halted' depends on axioms: [propext]", + "'CurrentMain.BinaryCarryIncrement.increment_length' depends on axioms: [propext]", + "'CurrentMain.BinaryCarryIncrement.value_binding' does not depend on any axioms", + "'CurrentMain.BinaryCarryIncrement.increment_modular_value' depends on axioms: [propext, Quot.sound]" + ], + "receipt_sha256": "5814c41487c0ff457689c5f70c02e3e9534348e6b03d4a98fed5ade131c90873", + "reused_verified_prefix": true, + "research_source_sha256": "b0f639159e2169c75e6d7a13663adee5107648a32b7ff9203f92792e31012dce", + "research_object_sha256": "07895c550c6298ae2143cca61c53399131f4b5a6a77b71f154c7ec6baa46ddc8", + "matches_research_object": true, + "matches_research_full_log": true + }, + { + "module": "BinaryCountDispatcher", + "source_sha256": "ec24af9483d59ce3248802378218d4b478490aa2458e136880f36e7f49356e93", + "status": "PASS", + "review_stop": false, + "exit_code": 0, + "timed_out": false, + "started_utc": "2026-10-12T00:37:46.304122+00:00", + "finished_utc": "2026-10-12T00:37:47.821305+00:00", + "compile_seconds": 1.5167703590013843, + "queue_seconds": 0.00037700100074289367, + "peak_vm_bytes": 2603061248, + "peak_rss_bytes": 1019551744, + "peak_threads": 9, + "samples": 16, + "complete_axiom_probes": [ + { + "declaration": "CurrentMain.BinaryCountDispatcher.count_run", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CurrentMain.BinaryCountDispatcher.final_halted", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CurrentMain.BinaryCountDispatcher.counter_length", + "axioms": [ + "propext" + ] + }, + { + "declaration": "CurrentMain.BinaryCountDispatcher.counter_value", + "axioms": [ + "propext", + "Quot.sound" + ] + } + ], + "expected_probes_match": true, + "slot": 0, + "log_sha256": "c54652b47292efff363956e0ec0af2eeb791be77b01213b6adbc7807576f81f1", + "object_sha256": "6685bcc5f2657f829149fa21e0140e063750680997c072cbe2c661e5190fa97e", + "imports": [ + "BinaryCarryIncrement" + ], + "axiom_output": [ + "'CurrentMain.BinaryCountDispatcher.count_run' depends on axioms: [propext, Quot.sound]", + "'CurrentMain.BinaryCountDispatcher.final_halted' depends on axioms: [propext, Quot.sound]", + "'CurrentMain.BinaryCountDispatcher.counter_length' depends on axioms: [propext]", + "'CurrentMain.BinaryCountDispatcher.counter_value' depends on axioms: [propext, Quot.sound]" + ], + "receipt_sha256": "423ad7de1a7e849d53779e172dd1cd11d379ca53052bd4130fc5533cb27218bd", + "reused_verified_prefix": true, + "research_source_sha256": "ec24af9483d59ce3248802378218d4b478490aa2458e136880f36e7f49356e93", + "research_object_sha256": "6685bcc5f2657f829149fa21e0140e063750680997c072cbe2c661e5190fa97e", + "matches_research_object": true, + "matches_research_full_log": false + }, + { + "module": "BinaryCountDispatcherMarkedInput", + "source_sha256": "b7f0cecb69194b8d851037e8321e245dc383c62e3e2475c9d4508d29390191cc", + "status": "PASS", + "review_stop": false, + "exit_code": 0, + "timed_out": false, + "started_utc": "2026-10-12T00:37:47.823317+00:00", + "finished_utc": "2026-10-12T00:37:51.041165+00:00", + "compile_seconds": 3.217338987997209, + "queue_seconds": 0.0006338769999274518, + "peak_vm_bytes": 2066223104, + "peak_rss_bytes": 1010667520, + "peak_threads": 6, + "samples": 26, + "complete_axiom_probes": [ + { + "declaration": "CurrentMain.BinaryCountDispatcherMarkedInput.count_run", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CurrentMain.BinaryCountDispatcherMarkedInput.final_halted", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CurrentMain.BinaryCountDispatcherMarkedInput.counter_length", + "axioms": [ + "propext" + ] + }, + { + "declaration": "CurrentMain.BinaryCountDispatcherMarkedInput.counter_value", + "axioms": [ + "propext", + "Quot.sound" + ] + } + ], + "expected_probes_match": true, + "slot": 0, + "log_sha256": "3067d6a5e9cbfe3ff1a19435b2e7392f68480ec46b5eefae9f998f49943a0dd8", + "object_sha256": "bd14ae558577205f11c534c7ee5264ec2f8c6f321c92b5b08521b221470f9346", + "imports": [ + "BinaryCountDispatcher" + ], + "axiom_output": [ + "'CurrentMain.BinaryCountDispatcherMarkedInput.count_run' depends on axioms: [propext, Quot.sound]", + "'CurrentMain.BinaryCountDispatcherMarkedInput.final_halted' depends on axioms: [propext, Quot.sound]", + "'CurrentMain.BinaryCountDispatcherMarkedInput.counter_length' depends on axioms: [propext]", + "'CurrentMain.BinaryCountDispatcherMarkedInput.counter_value' depends on axioms: [propext, Quot.sound]" + ], + "receipt_sha256": "8a625f18c401d76951ce90ea042d8ad08ab4d0dac90d3f5cdcdab2e1e9723367", + "reused_verified_prefix": true, + "research_source_sha256": "b7f0cecb69194b8d851037e8321e245dc383c62e3e2475c9d4508d29390191cc", + "research_object_sha256": "bd14ae558577205f11c534c7ee5264ec2f8c6f321c92b5b08521b221470f9346", + "matches_research_object": true, + "matches_research_full_log": true + }, + { + "module": "BinaryCounterZeroAllocation", + "source_sha256": "5cf3fdfcd6c6a6cefa89b9a83dc678b6f40d9a608c318334ae92a66d25ea7477", + "status": "PASS", + "review_stop": false, + "exit_code": 0, + "timed_out": false, + "started_utc": "2026-10-12T00:37:51.043058+00:00", + "finished_utc": "2026-10-12T00:37:52.285015+00:00", + "compile_seconds": 1.2415851190016838, + "queue_seconds": 0.00048325700117857195, + "peak_vm_bytes": 3074072576, + "peak_rss_bytes": 1011097600, + "peak_threads": 12, + "samples": 13, + "complete_axiom_probes": [ + { + "declaration": "CurrentMain.BinaryCounterZeroAllocation.allocate_run_exact", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CurrentMain.BinaryCounterZeroAllocation.final_halted", + "axioms": [ + "propext" + ] + }, + { + "declaration": "CurrentMain.BinaryCounterZeroAllocation.allocated_width", + "axioms": [ + "propext" + ] + } + ], + "expected_probes_match": true, + "slot": 0, + "log_sha256": "90de35142ca4dca8c3f4cd678abd99c728ab2ceb197abc0e5b14d2e566d3005c", + "object_sha256": "48910f8b0674b728aaff6eba2463df006822795b24402747f3512c24636e1d72", + "imports": [ + "BinaryCountDispatcherMarkedInput" + ], + "axiom_output": [ + "'CurrentMain.BinaryCounterZeroAllocation.allocate_run_exact' depends on axioms: [propext, Quot.sound]", + "'CurrentMain.BinaryCounterZeroAllocation.final_halted' depends on axioms: [propext]", + "'CurrentMain.BinaryCounterZeroAllocation.allocated_width' depends on axioms: [propext]" + ], + "receipt_sha256": "c7a23ffeeae8992003fcd14f345ddd655aaf2662e9b8e778f46d0fd9e614e2bb", + "reused_verified_prefix": true, + "research_source_sha256": "5cf3fdfcd6c6a6cefa89b9a83dc678b6f40d9a608c318334ae92a66d25ea7477", + "research_object_sha256": "48910f8b0674b728aaff6eba2463df006822795b24402747f3512c24636e1d72", + "matches_research_object": true, + "matches_research_full_log": true + }, + { + "module": "BinaryAutomaticWidthCount", + "source_sha256": "5dcf4ec74f08d9662738db413d144e16f4b555e56f29e0846ad5c88726420154", + "status": "PASS", + "review_stop": false, + "exit_code": 0, + "timed_out": false, + "started_utc": "2026-10-12T00:37:52.286734+00:00", + "finished_utc": "2026-10-12T00:37:53.679937+00:00", + "compile_seconds": 1.3928386750012578, + "queue_seconds": 0.00042648900125641376, + "peak_vm_bytes": 1731022848, + "peak_rss_bytes": 1009250304, + "peak_threads": 4, + "samples": 14, + "complete_axiom_probes": [ + { + "declaration": "CurrentMain.BinaryAutomaticWidthCount.count_run", + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ] + }, + { + "declaration": "CurrentMain.BinaryAutomaticWidthCount.final_halted", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CurrentMain.BinaryAutomaticWidthCount.final_input", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CurrentMain.BinaryAutomaticWidthCount.final_counter", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CurrentMain.BinaryAutomaticWidthCount.counter_width", + "axioms": [ + "propext" + ] + }, + { + "declaration": "CurrentMain.BinaryAutomaticWidthCount.counter_value", + "axioms": [ + "propext", + "Quot.sound" + ] + } + ], + "expected_probes_match": true, + "slot": 0, + "log_sha256": "185599ae81bb180e4452e3984dd46a2e419d85fc00f9e3196b88f21b00efcf3f", + "object_sha256": "2084a5516a72c995fa40f4f424ef2f94f88a0dbaff3fcbdaad153ff24470a503", + "imports": [ + "BinaryCounterZeroAllocation" + ], + "axiom_output": [ + "'CurrentMain.BinaryAutomaticWidthCount.count_run' depends on axioms: [propext, Classical.choice, Quot.sound]", + "'CurrentMain.BinaryAutomaticWidthCount.final_halted' depends on axioms: [propext, Quot.sound]", + "'CurrentMain.BinaryAutomaticWidthCount.final_input' depends on axioms: [propext, Quot.sound]", + "'CurrentMain.BinaryAutomaticWidthCount.final_counter' depends on axioms: [propext, Quot.sound]", + "'CurrentMain.BinaryAutomaticWidthCount.counter_width' depends on axioms: [propext]", + "'CurrentMain.BinaryAutomaticWidthCount.counter_value' depends on axioms: [propext, Quot.sound]" + ], + "receipt_sha256": "9ebc744caabb55bd290841c3e3b0048742cde06886aa256471d20de861c0e267", + "reused_verified_prefix": true, + "research_source_sha256": "5dcf4ec74f08d9662738db413d144e16f4b555e56f29e0846ad5c88726420154", + "research_object_sha256": "2084a5516a72c995fa40f4f424ef2f94f88a0dbaff3fcbdaad153ff24470a503", + "matches_research_object": true, + "matches_research_full_log": true + }, + { + "module": "RippleCounterListData", + "source_sha256": "6ad007faa04e8f22895489011f48c6574dca4a31809f3456fbcf5bea4a5bb302", + "status": "PASS", + "review_stop": false, + "exit_code": 0, + "timed_out": false, + "started_utc": "2026-10-12T00:37:53.681334+00:00", + "finished_utc": "2026-10-12T00:37:54.404169+00:00", + "compile_seconds": 0.7223440990019299, + "queue_seconds": 0.00033982500099227764, + "peak_vm_bytes": 1592246272, + "peak_rss_bytes": 1013473280, + "peak_threads": 3, + "samples": 8, + "complete_axiom_probes": [], + "expected_probes_match": true, + "slot": 0, + "log_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "object_sha256": "462675831d027a5c02f492a65881e9d0a681d6be9032ea5ae06cf6406251b9a0", + "imports": [ + "Lean", + "Mathlib.Algebra.Group.Nat.Defs", + "Mathlib.Tactic.SplitIfs" + ], + "axiom_output": [], + "receipt_sha256": "a9c068d2f0cfe4428819a827a00420b3026732d74a8db2607d90df653520405b", + "reused_verified_prefix": true, + "research_source_sha256": "6ad007faa04e8f22895489011f48c6574dca4a31809f3456fbcf5bea4a5bb302", + "research_object_sha256": "462675831d027a5c02f492a65881e9d0a681d6be9032ea5ae06cf6406251b9a0", + "matches_research_object": true, + "matches_research_full_log": true + }, + { + "module": "CounterArithmeticPure", + "source_sha256": "7fea5026e56a66f10bcda803c1c8b6f5b3745f029840cc09eb4f6fa197990e0b", + "status": "PASS", + "review_stop": false, + "exit_code": 0, + "timed_out": false, + "started_utc": "2026-10-12T00:43:12.807566+00:00", + "finished_utc": "2026-10-12T00:43:15.137393+00:00", + "compile_seconds": 2.3288924470034544, + "queue_seconds": 0.0005695200015907176, + "peak_vm_bytes": 1768620032, + "peak_rss_bytes": 1053339648, + "peak_threads": 4, + "samples": 23, + "complete_axiom_probes": [ + { + "declaration": "CounterArithmetic.updated_nil", + "axioms": [] + }, + { + "declaration": "CounterArithmetic.updated_carry", + "axioms": [ + "propext" + ] + }, + { + "declaration": "CounterArithmetic.updated_stop", + "axioms": [ + "propext" + ] + }, + { + "declaration": "CounterArithmetic.updated_length", + "axioms": [ + "propext" + ] + }, + { + "declaration": "CounterArithmetic.carryLength_le_length", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CounterArithmetic.potential_le_length", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CounterArithmetic.potential_accounting", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CounterArithmetic.amortized_step", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CounterArithmetic.iterate_length", + "axioms": [ + "propext" + ] + }, + { + "declaration": "CounterArithmetic.amortized_total", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CounterArithmetic.total_steps_bound", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CounterArithmetic.value_bound", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CounterArithmetic.increment_value", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CounterArithmetic.decrement_value", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CounterArithmetic.decrement_underflow_iff_zero", + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ] + }, + { + "declaration": "CounterArithmetic.overflow_updated", + "axioms": [ + "propext" + ] + }, + { + "declaration": "CounterArithmetic.zero_replicate_value", + "axioms": [ + "propext" + ] + }, + { + "declaration": "CounterArithmetic.increment_overflow_iff_max", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CounterArithmetic.decrement_positive", + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ] + }, + { + "declaration": "CounterArithmetic.countdown_value", + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ] + }, + { + "declaration": "CounterArithmetic.countdown_not_finished", + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ] + }, + { + "declaration": "CounterArithmetic.countdown_final_underflow", + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ] + }, + { + "declaration": "CounterArithmetic.complete_block_cost", + "axioms": [ + "propext", + "Quot.sound" + ] + } + ], + "expected_probes_match": true, + "slot": 0, + "log_sha256": "dda3fbe314a2f36a2e2fab87bf929c88a4cd469102c51a7e8e0f0c65bc175be0", + "object_sha256": "fbeef1327323a7b85940eff1f506eb3f4eb840a40ac9a1bacf8980ae09509e98", + "imports": [ + "RippleCounterListData" + ], + "axiom_output": [ + "'CounterArithmetic.updated_nil' does not depend on any axioms", + "'CounterArithmetic.updated_carry' depends on axioms: [propext]", + "'CounterArithmetic.updated_stop' depends on axioms: [propext]", + "'CounterArithmetic.updated_length' depends on axioms: [propext]", + "'CounterArithmetic.carryLength_le_length' depends on axioms: [propext, Quot.sound]", + "'CounterArithmetic.potential_le_length' depends on axioms: [propext, Quot.sound]", + "'CounterArithmetic.potential_accounting' depends on axioms: [propext, Quot.sound]", + "'CounterArithmetic.amortized_step' depends on axioms: [propext, Quot.sound]", + "'CounterArithmetic.iterate_length' depends on axioms: [propext]", + "'CounterArithmetic.amortized_total' depends on axioms: [propext, Quot.sound]", + "'CounterArithmetic.total_steps_bound' depends on axioms: [propext, Quot.sound]", + "'CounterArithmetic.value_bound' depends on axioms: [propext, Quot.sound]", + "'CounterArithmetic.increment_value' depends on axioms: [propext, Quot.sound]", + "'CounterArithmetic.decrement_value' depends on axioms: [propext, Quot.sound]", + "'CounterArithmetic.decrement_underflow_iff_zero' depends on axioms: [propext, Classical.choice, Quot.sound]", + "'CounterArithmetic.overflow_updated' depends on axioms: [propext]", + "'CounterArithmetic.zero_replicate_value' depends on axioms: [propext]", + "'CounterArithmetic.increment_overflow_iff_max' depends on axioms: [propext, Quot.sound]", + "'CounterArithmetic.decrement_positive' depends on axioms: [propext, Classical.choice, Quot.sound]", + "'CounterArithmetic.countdown_value' depends on axioms: [propext, Classical.choice, Quot.sound]", + "'CounterArithmetic.countdown_not_finished' depends on axioms: [propext, Classical.choice, Quot.sound]", + "'CounterArithmetic.countdown_final_underflow' depends on axioms: [propext, Classical.choice, Quot.sound]", + "'CounterArithmetic.complete_block_cost' depends on axioms: [propext, Quot.sound]" + ], + "receipt_sha256": "9c9f11ef0bf0a9a82bdc86f524c97ad675e758a9fc2dacedbb1770fc8f68a83d", + "reused_verified_prefix": false, + "research_source_sha256": "1ad26524cc5932842e8f233aa3b8b4f9c0ecb12a4ab06478c6c6f0c42827144b", + "research_object_sha256": "3d3ef80267e98928090af6bb49c4a01790f93541b11c8c953c4f382119281b9d", + "matches_research_object": false, + "matches_research_full_log": true + }, + { + "module": "BinaryCountReceiptAmortization", + "source_sha256": "48f51cf3387fbcd88c75f05bd7714716be33b5590f976a3519fa025ea64bba08", + "status": "PASS", + "review_stop": false, + "exit_code": 0, + "timed_out": false, + "started_utc": "2026-10-12T00:43:15.139718+00:00", + "finished_utc": "2026-10-12T00:43:16.095072+00:00", + "compile_seconds": 0.9549631320005574, + "queue_seconds": 0.0007128139986889437, + "peak_vm_bytes": 1772691456, + "peak_rss_bytes": 1047412736, + "peak_threads": 4, + "samples": 10, + "complete_axiom_probes": [ + { + "declaration": "CurrentMain.BinaryCountReceiptAmortization.prefix_binding", + "axioms": [ + "propext" + ] + }, + { + "declaration": "CurrentMain.BinaryCountReceiptAmortization.increment_binding", + "axioms": [ + "propext" + ] + }, + { + "declaration": "CurrentMain.BinaryCountReceiptAmortization.increment_reads_binding", + "axioms": [ + "propext" + ] + }, + { + "declaration": "CurrentMain.BinaryCountReceiptAmortization.pass_result_binding", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CurrentMain.BinaryCountReceiptAmortization.pass_reads_binding", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CurrentMain.BinaryCountReceiptAmortization.pass_reads_le", + "axioms": [ + "propext", + "Quot.sound" + ] + }, + { + "declaration": "CurrentMain.BinaryCountReceiptAmortization.count_run_linear", + "axioms": [ + "propext", + "Classical.choice", + "Quot.sound" + ] + } + ], + "expected_probes_match": true, + "slot": 0, + "log_sha256": "2732113b6167e7b2d20f6b3944acf349cbfd6b9e4454d082a072c4274f49ca1a", + "object_sha256": "4eb3451b2ab99adf5407556ed95e2cf4e7ff76dc63b9f549152928df445aad37", + "imports": [ + "CounterArithmeticPure", + "BinaryAutomaticWidthCount" + ], + "axiom_output": [ + "'CurrentMain.BinaryCountReceiptAmortization.prefix_binding' depends on axioms: [propext]", + "'CurrentMain.BinaryCountReceiptAmortization.increment_binding' depends on axioms: [propext]", + "'CurrentMain.BinaryCountReceiptAmortization.increment_reads_binding' depends on axioms: [propext]", + "'CurrentMain.BinaryCountReceiptAmortization.pass_result_binding' depends on axioms: [propext, Quot.sound]", + "'CurrentMain.BinaryCountReceiptAmortization.pass_reads_binding' depends on axioms: [propext, Quot.sound]", + "'CurrentMain.BinaryCountReceiptAmortization.pass_reads_le' depends on axioms: [propext, Quot.sound]", + "'CurrentMain.BinaryCountReceiptAmortization.count_run_linear' depends on axioms: [propext, Classical.choice, Quot.sound]" + ], + "receipt_sha256": "596b1101a3a270848e2279ee4f398369ee8e0f802550e76912815264c1dfb912", + "reused_verified_prefix": false, + "research_source_sha256": "48f51cf3387fbcd88c75f05bd7714716be33b5590f976a3519fa025ea64bba08", + "research_object_sha256": "4eb3451b2ab99adf5407556ed95e2cf4e7ff76dc63b9f549152928df445aad37", + "matches_research_object": true, + "matches_research_full_log": true + } + ] +} diff --git a/research/lean-count-receipt-amortization/RippleCounterListData.lean b/research/lean-count-receipt-amortization/RippleCounterListData.lean new file mode 100644 index 0000000000..ab12ee98a8 --- /dev/null +++ b/research/lean-count-receipt-amortization/RippleCounterListData.lean @@ -0,0 +1,28 @@ +import Lean +import Mathlib.Algebra.Group.Nat.Defs +import Mathlib.Tactic.SplitIfs + +/-! Exact five list definitions extracted from the published PR64 RippleCounter. +No tape execution or new counter/potential proof is included. The original +source and current-main publication manifest are retained by the correspondence +audit; this module must not be jointly imported with the original RippleCounter. -/ +namespace RippleCounter + +def carryLength (d : Bool) : List Bool → ℕ + | [] => 0 + | b::rest => if b = d then carryLength d rest + 1 else 0 + +def stopTail (d : Bool) : List Bool → List Bool + | [] => [] + | b::rest => if b = d then stopTail d rest else (!b) :: rest + +def overflow (d : Bool) : List Bool → Bool + | [] => true + | b::rest => if b = d then overflow d rest else false + +def updated (d : Bool) (bits : List Bool) : List Bool := + List.replicate (carryLength d bits) (!d) ++ stopTail d bits + +def steps (d : Bool) (bits : List Bool) : ℕ := 2 * carryLength d bits + 2 + +end RippleCounter diff --git a/research/lean-count-receipt-amortization/SHA256SUMS b/research/lean-count-receipt-amortization/SHA256SUMS new file mode 100644 index 0000000000..c2b1f113c6 --- /dev/null +++ b/research/lean-count-receipt-amortization/SHA256SUMS @@ -0,0 +1,17 @@ +902aaa43cef17b08426707b44c7f23a482b28de3cfd09372d561dc244e25beb2 ACCEPTED_CHECKS.json +7452db0676f86dce69cec62f5db57c4709fea33df994fd13e1db30d1c71e3c4a AUTHOR_CHECK.json +48f51cf3387fbcd88c75f05bd7714716be33b5590f976a3519fa025ea64bba08 BinaryCountReceiptAmortization.lean +7fea5026e56a66f10bcda803c1c8b6f5b3745f029840cc09eb4f6fa197990e0b CounterArithmeticPure.lean +324158e7e76ba677bfe3cbd4aa092c3cb87bb04065d6bb12d78dcdb89a991be6 DEPENDENCIES.json +2e29aae6cd405281d34d718395ab98f4adab083c64b34341fa7c8a879e6a1dd1 EXTERNAL_OBJECTS.json +c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4 LICENSE +169758c45c3f0ab3b48920793d766ecdd5221e56e72cb9683a8681c6f75bfacb MANIFEST.json +b49022cb4104d90b182e4c335f670faf45529025b15db77bf0291835083c28bd NOTICE +d17146028b62acb753b712f8291ac1a3df43dd4116e60e91f18bdf42fd6bf7c2 PROVENANCE.json +7bfbe62e7290d87bfb210680ea618fb3f01e3fe4d11d753bbabf55331c722421 PUBLIC_SOURCE_CHANGES.json +36f7916048b725ba176a7b40966f1668aa6df71b7c29c5d16130e20862894ddd README.md +274c3dc5c100dd125ef41af06778cde816faf70da321aced4e5fa55eb04fffd0 REPLAY_SUMMARY.json +6ad007faa04e8f22895489011f48c6574dca4a31809f3456fbcf5bea4a5bb302 RippleCounterListData.lean +ba21a7de1547b79161d17d4c9f2c8a1c6a4806ffa9681d3acd1bc65ba066d2f2 check.py +d24fed434d3b13adfaab57724a0a7f270ea8bf1c818b5ae5cf25cbce24dd685c lean-toolchain +df836c6d34509e980d067bd5678489c968bc6e329af9dd82c6207abf6443da89 selected-result.json diff --git a/research/lean-count-receipt-amortization/check.py b/research/lean-count-receipt-amortization/check.py new file mode 100644 index 0000000000..973d6b31c9 --- /dev/null +++ b/research/lean-count-receipt-amortization/check.py @@ -0,0 +1,102 @@ +#!/usr/bin/env python3 +"""Offline twelve-source receipt-transport replay using nine pinned PR sources and an exact existing Mathlib cache.""" +import argparse,fcntl,hashlib,importlib.util,json,os,re,resource,signal,subprocess,time,shutil +from pathlib import Path +from datetime import datetime,timezone +ROOT=Path(__file__).resolve().parent +sha=lambda p:hashlib.sha256(Path(p).read_bytes()).hexdigest() +now=lambda:datetime.now(timezone.utc).isoformat() +def limits(): + resource.setrlimit(resource.RLIMIT_AS,(4*1024**3,4*1024**3)) + resource.setrlimit(resource.RLIMIT_CPU,(60,62));os.setsid() +def complete_probes(text): + result=[] + pattern=r"'([^']+)' (?:does not depend on any axioms|depends on axioms: \[([^\]]*)\])" + for m in re.finditer(pattern,text,re.S): + result.append({'declaration':m[1],'axioms':[] if m[2] is None else [a.strip() for a in m[2].split(',') if a.strip()]}) + return result + +def verify_external(lean,mathlib): + manifest=json.loads((ROOT/'EXTERNAL_OBJECTS.json').read_text()) + assert sha(lean)==manifest['lean_binary_sha256'] + assert manifest['mathlib_commit']=='308445d7985027f538e281e18df29ca16ede2ba3' + roots={'lean':lean.parent.parent,'mathlib':mathlib} + paths=[mathlib/p for p in manifest['library_paths_relative_to_mathlib']] + assert len(paths)==8 and len(manifest['modules'])==1366 + assert all(p.is_dir() for p in paths) + names={r['module'] for r in manifest['modules']};assert len(names)==1366 + for row in manifest['modules']: + source=roots[row['root']]/row['source_path'];obj=roots[row['root']]/row['object_path'] + assert source.is_file() and obj.is_file() and sha(source)==row['source_sha256'] and sha(obj)==row['object_sha256'],row['module'] + assert obj.stat().st_size==row['object_bytes'] and set(row['imports'])<=names,row['module'] + relative=Path(*row['module'].split('.')).with_suffix('.olean') + resolved=next((p/relative for p in paths+[roots['lean']/'lib/lean'] if (p/relative).is_file()),None) + assert resolved is not None and resolved.resolve()==obj.resolve(),row['module'] + return manifest,paths,names + +def main(): + ap=argparse.ArgumentParser();ap.add_argument('--lean',required=True);ap.add_argument('--input-foundation-root',required=True,help='Exact PR488 input-preparation package.');ap.add_argument('--dispatcher-foundation-root',required=True,help='Exact PR511 count-dispatcher package.');ap.add_argument('--automatic-width-root',required=True,help='Exact PR519 automatic-width package.');ap.add_argument('--mathlib-root',required=True,help='Existing exact Mathlib4.21 cache tree; no downloads.');ap.add_argument('--build-dir',default='.build');ap.add_argument('--slot-service',help='Optional existing FIFO slot service exposing acquire(); does not change Lean inputs.');ap.add_argument('--lean-sha256');args=ap.parse_args() + assert Path('/proc/self/status').is_file(),'Linux /proc is required for the stated memory review' + roots={'package':ROOT,'pr488':Path(args.input_foundation_root).resolve(),'pr511':Path(args.dispatcher_foundation_root).resolve(),'pr519':Path(args.automatic_width_root).resolve()} + assert all(p.is_dir() for p in roots.values()) + source_for=lambda row:roots[row['origin']]/row['file'] + lean=Path(args.lean).resolve();assert lean.is_file() + if args.lean_sha256:assert sha(lean)==args.lean_sha256 + version=subprocess.check_output([str(lean),'--version'],text=True).strip();assert re.search(r'\b4\.21\.0\b',version),version + external,external_paths,external_names=verify_external(lean,Path(args.mathlib_root).resolve()) + manifest=json.loads((ROOT/'MANIFEST.json').read_text());rows=manifest['compile_order'];names={r['module']for r in rows};seen=set() + assert not names & external_names + assert len(rows)==12 and manifest['source_bytes']==91019 + assert sum(r['origin']=='pr488' for r in rows)==2 and sum(r['origin']=='pr511' for r in rows)==4 and sum(r['origin']=='pr519' for r in rows)==3 and sum(r['origin']=='package' for r in rows)==3 + dependencies=json.loads((ROOT/'DEPENDENCIES.json').read_text()) + expected_commits={'pr488':'edd3102b415df5b9d6f633ac0a4dedcf69c58525','pr511':'79f7c03c7f820ab89955b75ef239cbaccc627e6e','pr519':'ffd3c48a80ba8b579dc300e785e387fe8acddfef'} + assert set(dependencies)==set(expected_commits) + for alias,dependency in dependencies.items(): + assert dependency['commit']==expected_commits[alias] + for dep in dependency['files']: + row=next(r for r in rows if r['module']==dep['module']);assert row['origin']==alias and row['sha256']==dep['sha256'] and row['bytes']==dep['bytes'] + for row in rows: + p=source_for(row);assert p.is_file()and sha(p)==row['sha256']and p.stat().st_size==row['bytes'],row['module'] + imports=[] + for line in p.read_text().splitlines(): + m=re.match(r'^import\s+(.+)$',line) + if m:imports.extend(m[1].split('--',1)[0].split()) + assert imports==row['imports'];assert set(imports)<=seen|external_names;seen.add(row['module']) + assert sum(len(r['expected_probes']) for r in rows)==79 + build=Path(args.build_dir);build=build if build.is_absolute()else ROOT/build;build.mkdir(parents=True,exist_ok=False);(build/'logs').mkdir();(build/'receipts').mkdir();(build/'sources').mkdir();(build/'objects').mkdir() + build=build.resolve() + for row in rows: + target=build/'sources'/(row['module']+'.lean');shutil.copyfile(source_for(row),target);assert sha(target)==row['sha256'] + for module in names: + assert not any((p/(module+'.olean')).exists() for p in external_paths),module + service=None + if args.slot_service: + spec=importlib.util.spec_from_file_location('existing_lean_slot_service',Path(args.slot_service).resolve());service=importlib.util.module_from_spec(spec);spec.loader.exec_module(service) + env=dict(os.environ);env['LEAN_PATH']=os.pathsep.join([str(build/'objects')]+[str(p) for p in external_paths]);env['LEAN_EXTRA_PATHS']='';env.pop('LEAN_SYSROOT',None);env['MIMALLOC_ARENA_RESERVE']='64MiB' + outcome={'started_utc':now(),'manifest_sha256':sha(ROOT/'MANIFEST.json'),'dependencies_manifest_sha256':sha(ROOT/'DEPENDENCIES.json'),'dependency_commits':expected_commits,'lean_version':version,'lean_binary_sha256':sha(lean),'external_manifest_sha256':sha(ROOT/'EXTERNAL_OBJECTS.json'),'external_library_paths':[str(p) for p in external_paths],'source_search_path':env['LEAN_PATH'],'status':'RUNNING','receipts':[]};(build/'REPLAY_RESULT.json').write_text(json.dumps(outcome,indent=2)+'\n') + for row in rows: + requested=time.monotonic();slot=None;handle=None;handles=[] + if service:slot,handle,handles=service.acquire('isolated_receipt_amortization_package:'+row['module']) + queue=time.monotonic()-requested;started=time.monotonic();start_utc=now();source=build/'sources'/(row['module']+'.lean');output_path=build/'objects'/(row['module']+'.olean');log=build/'logs'/(row['module']+'.log');peak=0;peak_rss=0;peak_threads=0;samples=0;timed_out=False + try: + assert sha(source)==row['sha256'];cmd=[str(lean),'-s','65536','-j','1','-o',str(output_path),source.name] + proc=subprocess.Popen(cmd,cwd=source.parent,env=env,stdout=subprocess.PIPE,stderr=subprocess.STDOUT,preexec_fn=limits) + while True: + try: + text=Path(f'/proc/{proc.pid}/status').read_text();m=re.search(r'^VmPeak:\s+(\d+)',text,re.M);peak=max(peak,int(m[1])*1024 if m else 0);m=re.search(r'^VmHWM:\s+(\d+)',text,re.M);peak_rss=max(peak_rss,int(m[1])*1024 if m else 0);m=re.search(r'^Threads:\s+(\d+)',text,re.M);peak_threads=max(peak_threads,int(m[1]) if m else 0);samples+=1 + except OSError:pass + remaining=60-(time.monotonic()-started) + if remaining<=0: + timed_out=True;os.killpg(proc.pid,signal.SIGKILL);data,_=proc.communicate();break + try:data,_=proc.communicate(timeout=min(.1,remaining));break + except subprocess.TimeoutExpired:pass + elapsed=time.monotonic()-started;log.write_bytes(data);text=data.decode(errors='replace');forbidden=('sorryAx'in text or "declaration uses 'sorry'"in text) + probes=complete_probes(text);probe_match=probes==row['expected_probes'] and all(set(p['axioms'])<={'propext','Classical.choice','Quot.sound'} for p in probes) + passed=proc.returncode==0 and not timed_out and not forbidden and probe_match and output_path.is_file()and sha(source)==row['sha256']and sha(source_for(row))==row['sha256'];review=passed and(elapsed>40 or peak>int(3.5*1024**3)) + rec={'module':row['module'],'source_sha256':row['sha256'],'status':'PASS'if passed else'FAIL','review_stop':review,'exit_code':proc.returncode,'timed_out':timed_out,'started_utc':start_utc,'finished_utc':now(),'compile_seconds':elapsed,'queue_seconds':queue,'peak_vm_bytes':peak,'peak_rss_bytes':peak_rss,'peak_threads':peak_threads,'samples':samples,'complete_axiom_probes':probes,'expected_probes_match':probe_match,'slot':slot,'log_sha256':sha(log),'object_sha256':sha(output_path)if passed else None,'imports':row['imports'],'axiom_output':[s for s in text.splitlines()if'depends on axioms:'in s or'does not depend on any axioms'in s]};rp=build/'receipts'/(row['module']+'.json');rp.write_text(json.dumps(rec,indent=2)+'\n');outcome['receipts'].append({'module':row['module'],'receipt_sha256':sha(rp),'status':rec['status']});outcome['status']='REVIEW_STOP'if review else('RUNNING'if passed else'FAIL');(build/'REPLAY_RESULT.json').write_text(json.dumps(outcome,indent=2)+'\n');print(json.dumps(rec),flush=True) + if not passed or review:return 2 + finally: + if handle:fcntl.flock(handle,fcntl.LOCK_UN) + for h in handles:h.close() + outcome['status']='PASS';outcome['finished_utc']=now();outcome['modules']=len(outcome['receipts']);(build/'REPLAY_RESULT.json').write_text(json.dumps(outcome,indent=2)+'\n');print('PASS exact isolated12-module receipt-amortization closure',flush=True);return 0 +if __name__=='__main__':raise SystemExit(main()) diff --git a/research/lean-count-receipt-amortization/lean-toolchain b/research/lean-count-receipt-amortization/lean-toolchain new file mode 100644 index 0000000000..980709bbba --- /dev/null +++ b/research/lean-count-receipt-amortization/lean-toolchain @@ -0,0 +1 @@ +leanprover/lean4:v4.21.0 diff --git a/research/lean-count-receipt-amortization/selected-result.json b/research/lean-count-receipt-amortization/selected-result.json new file mode 100644 index 0000000000..af3efd2f01 --- /dev/null +++ b/research/lean-count-receipt-amortization/selected-result.json @@ -0,0 +1,33 @@ +{ + "status": "Published on main: maintainer-reviewed conditional construction", + "kappa": "90446448750933/125000000000000000", + "decimal": "0.000723571590007464", + "source_prs": [ + 279, + 276, + 244, + 234, + 209, + 197, + 237, + 200, + 193, + 168, + 144 + ], + "source_manifest": "research/five-stage-gen4-banks/MANIFEST.json", + "certificate": "research/community-pr279-audit/certificate.json", + "certificate_sha256": "6a457a34b4db57417e5b253cf1c169da2bd6aff4c21363a31fd85dc931d49589", + "proof": "research/five-stage-gen4-banks/PROOF.md", + "proof_supplements": { + "research/five-stage-gen4-banks/BANK-PROOF.md": "bbc328e05848a211c981288514380a4ba12fddaed16c9d23328b5764502be411" + }, + "review": "docs/research/community-pr279-review.md", + "validation": "docs/research/community-pr279-integration.json", + "reproduce": "make gen4-bank-verify", + "scope": "Conditional on retained all-size compiler, weighted/common-ancestor chart, restored rows, selectors/routing, prime supply, precision/recovery, complex symbolic correctness and analytic transfer; finite replay and written review, not a full formal multiplication theorem.", + "previous_kappa": "330942774629799/500000000000000000", + "previous_certificate": "research/coordinated-frames-and-entrance-banks/certificate.json", + "previous_audited_kappa": "710046193349537/1000000000000000000", + "audited_source_head": "4d8c31eec7ae618645cb058101cb4e72a97268d3" +} diff --git a/scripts/experiments/joint_dual_compose.py b/scripts/experiments/joint_dual_compose.py index 1db1f1f606..ae8fdf1248 100644 --- a/scripts/experiments/joint_dual_compose.py +++ b/scripts/experiments/joint_dual_compose.py @@ -60,7 +60,7 @@ def check_sources(): required.update(f'certificates/joint-dual-{kind}-{h}.{extension}' for h in (23,25) for kind, extension in (('word','json.gz'),('profiles','json'),('transitions','json'))) required.update(('certificates/joint-dual-compiler.json', 'certificates/skip-frame-kappa.json', - 'scripts/experiments/pin_joint_dual_sources.py', 'Makefile', 'README.md', 'NOTICE')) + 'scripts/experiments/pin_joint_dual_sources.py')) comparison = ROOT/'references/frame-compiler/pr58' required.add('references/frame-compiler/pr58/SOURCE.json') required.update('references/frame-compiler/pr58/'+name diff --git a/scripts/experiments/pin_joint_dual_sources.py b/scripts/experiments/pin_joint_dual_sources.py index 94ec6bd77b..0b0299088a 100644 --- a/scripts/experiments/pin_joint_dual_sources.py +++ b/scripts/experiments/pin_joint_dual_sources.py @@ -12,7 +12,7 @@ def run(): names = {'scripts/experiments/'+name for name in NAMES} - names.update(('Makefile', 'README.md', 'NOTICE', 'research/joint-dual/README.md', + names.update(('research/joint-dual/README.md', 'research/joint-dual/PROOF.md', 'certificates/joint-dual-compiler.json', 'certificates/skip-frame-kappa.json', 'tests/test_joint_reclaim.py')) for h in (23,25):